juno-code 1.0.35 → 1.0.37

package/dist/bin/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import fs2 from 'fs-extra';
+import fs3 from 'fs-extra';
 import * as path3 from 'path';
 import path3__default, { dirname, join } from 'path';
 import * as os4 from 'os';
@@ -142,8 +142,8 @@ var init_types = __esm({
     };
     FileSystemError = class extends CLIError {
       code = "FILESYSTEM_ERROR";
-      constructor(message, path23) {
-        super(path23 ? `${message}: ${path23}` : message);
+      constructor(message, path24) {
+        super(path24 ? `${message}: ${path24}` : message);
         this.suggestions = [
           "Check file/directory permissions",
           "Verify path exists and is accessible",
@@ -282,6 +282,13 @@ var init_default_hooks = __esm({
   "src/templates/default-hooks.ts"() {
     init_version();
     DEFAULT_HOOKS = {
+      // Executes once at the beginning of a run (before all iterations)
+      // Use for: setup, environment checks, notifications, pre-run cleanup
+      START_RUN: {
+        commands: []
+      },
+      // Executes at the start of each iteration
+      // Use for: file monitoring, state checks, per-iteration setup
       START_ITERATION: {
         commands: [
           // Monitor CLAUDE.md file size
@@ -290,6 +297,16 @@ var init_default_hooks = __esm({
           'file="AGENTS.md"; lines=$(wc -l < "$file" 2>/dev/null || echo 0); chars=$(wc -m < "$file" 2>/dev/null || echo 0); if [ "$lines" -gt 450 ] || [ "$chars" -gt 60000 ]; then juno-kanban "[Critical] file $file is too large, keep it lean and useful for every run of the agent."; fi',
           "./.juno_task/scripts/cleanup_feedback.sh"
         ]
+      },
+      // Executes at the end of each iteration
+      // Use for: validation, logging, per-iteration cleanup, progress tracking
+      END_ITERATION: {
+        commands: []
+      },
+      // Executes once at the end of a run (after all iterations complete)
+      // Use for: final cleanup, notifications, reports, post-run actions
+      END_RUN: {
+        commands: []
       }
     };
   }
@@ -305,8 +322,21 @@ var init_service_installer = __esm({
   "src/utils/service-installer.ts"() {
     init_version();
     ServiceInstaller = class {
+      static REQUIRED_SCRIPTS = ["codex.py", "claude.py", "gemini.py"];
       static SERVICES_DIR = path3.join(homedir(), ".juno_code", "services");
       static VERSION_FILE = path3.join(homedir(), ".juno_code", "services", ".version");
+      static missingScripts(baseDir) {
+        return this.REQUIRED_SCRIPTS.filter((file) => !fs3.existsSync(path3.join(baseDir, file)));
+      }
+      static async missingScriptsAsync(baseDir) {
+        const results = await Promise.all(
+          this.REQUIRED_SCRIPTS.map(async (file) => ({
+            file,
+            exists: await fs3.pathExists(path3.join(baseDir, file))
+          }))
+        );
+        return results.filter((result) => !result.exists).map((result) => result.file);
+      }
       /**
        * Get the current package version
        */
@@ -315,12 +345,12 @@ var init_service_installer = __esm({
           const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
           const require3 = createRequire(import.meta.url);
           let packageJsonPath = path3.join(__dirname2, "..", "..", "package.json");
-          if (fs2.existsSync(packageJsonPath)) {
+          if (fs3.existsSync(packageJsonPath)) {
             const packageJson2 = require3(packageJsonPath);
             return packageJson2.version;
           }
           packageJsonPath = path3.join(__dirname2, "..", "..", "..", "package.json");
-          if (fs2.existsSync(packageJsonPath)) {
+          if (fs3.existsSync(packageJsonPath)) {
             const packageJson2 = require3(packageJsonPath);
             return packageJson2.version;
           }
@@ -334,11 +364,11 @@ var init_service_installer = __esm({
        */
       static async getInstalledVersion() {
         try {
-          const exists = await fs2.pathExists(this.VERSION_FILE);
+          const exists = await fs3.pathExists(this.VERSION_FILE);
           if (!exists) {
             return null;
           }
-          const version3 = await fs2.readFile(this.VERSION_FILE, "utf-8");
+          const version3 = await fs3.readFile(this.VERSION_FILE, "utf-8");
           return version3.trim();
         } catch {
           return null;
@@ -349,7 +379,7 @@ var init_service_installer = __esm({
        */
       static async saveVersion() {
         const version3 = this.getPackageVersion();
-        await fs2.writeFile(this.VERSION_FILE, version3, "utf-8");
+        await fs3.writeFile(this.VERSION_FILE, version3, "utf-8");
       }
       /**
        * Check if services need to be updated based on version
@@ -361,7 +391,7 @@ var init_service_installer = __esm({
           if (!installedVersion) {
             return true;
           }
-          const exists = await fs2.pathExists(this.SERVICES_DIR);
+          const exists = await fs3.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return true;
           }
@@ -369,32 +399,22 @@ var init_service_installer = __esm({
             return true;
           }
           if (semver.eq(packageVersion, installedVersion)) {
-            const installedCodex = path3.join(this.SERVICES_DIR, "codex.py");
-            const installedClaude = path3.join(this.SERVICES_DIR, "claude.py");
-            const codexExists = await fs2.pathExists(installedCodex);
-            const claudeExists = await fs2.pathExists(installedClaude);
-            if (!codexExists || !claudeExists) {
+            const missingInstalled = await this.missingScriptsAsync(this.SERVICES_DIR);
+            if (missingInstalled.length > 0) {
               return true;
             }
             try {
               const packageServicesDir = this.getPackageServicesDir();
-              const packageCodex = path3.join(packageServicesDir, "codex.py");
-              const packageClaude = path3.join(packageServicesDir, "claude.py");
-              const packageCodexExists = await fs2.pathExists(packageCodex);
-              const packageClaudeExists = await fs2.pathExists(packageClaude);
-              if (packageCodexExists) {
-                const [pkg, inst] = await Promise.all([
-                  fs2.readFile(packageCodex, "utf-8"),
-                  fs2.readFile(installedCodex, "utf-8")
-                ]);
-                if (pkg !== inst) {
-                  return true;
-                }
+              const missingPackageScripts = this.missingScripts(packageServicesDir);
+              if (missingPackageScripts.length > 0) {
+                throw new Error(`Missing required service scripts: ${missingPackageScripts.join(", ")}`);
               }
-              if (packageClaudeExists) {
+              for (const script of this.REQUIRED_SCRIPTS) {
+                const packageScript = path3.join(packageServicesDir, script);
+                const installedScript = path3.join(this.SERVICES_DIR, script);
                 const [pkg, inst] = await Promise.all([
-                  fs2.readFile(packageClaude, "utf-8"),
-                  fs2.readFile(installedClaude, "utf-8")
+                  fs3.readFile(packageScript, "utf-8"),
+                  fs3.readFile(installedScript, "utf-8")
                 ]);
                 if (pkg !== inst) {
                   return true;
@@ -418,15 +438,27 @@ var init_service_installer = __esm({
        */
       static getPackageServicesDir() {
         const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
-        let servicesPath = path3.join(__dirname2, "..", "..", "templates", "services");
-        if (fs2.existsSync(servicesPath)) {
-          return servicesPath;
-        }
-        servicesPath = path3.join(__dirname2, "..", "templates", "services");
-        if (fs2.existsSync(servicesPath)) {
-          return servicesPath;
+        const candidates = [
+          path3.join(__dirname2, "..", "..", "templates", "services"),
+          // dist (production)
+          path3.join(__dirname2, "..", "templates", "services")
+          // src (development)
+        ];
+        for (const servicesPath of candidates) {
+          if (!fs3.existsSync(servicesPath)) {
+            continue;
+          }
+          const missing = this.missingScripts(servicesPath);
+          if (missing.length === 0) {
+            return servicesPath;
+          }
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error(`[DEBUG] Services path missing required scripts (${servicesPath}): ${missing.join(", ")}`);
+          }
         }
-        throw new Error("Could not find services directory in package");
+        throw new Error(
+          "Could not find services directory in package containing codex.py, claude.py, and gemini.py. Try reinstalling juno-code or re-running npm run build to refresh service scripts."
+        );
       }
       /**
        * Install all service scripts to ~/.juno_code/services/
@@ -434,18 +466,22 @@ var init_service_installer = __esm({
        */
       static async install(silent = false) {
         try {
-          await fs2.ensureDir(this.SERVICES_DIR);
+          await fs3.ensureDir(this.SERVICES_DIR);
           const packageServicesDir = this.getPackageServicesDir();
-          await fs2.copy(packageServicesDir, this.SERVICES_DIR, {
+          await fs3.copy(packageServicesDir, this.SERVICES_DIR, {
             overwrite: true,
             preserveTimestamps: true
           });
-          const files = await fs2.readdir(this.SERVICES_DIR);
+          const missingAfterCopy = await this.missingScriptsAsync(this.SERVICES_DIR);
+          if (missingAfterCopy.length > 0) {
+            throw new Error(`Installed services missing required service scripts: ${missingAfterCopy.join(", ")}`);
+          }
+          const files = await fs3.readdir(this.SERVICES_DIR);
           for (const file of files) {
             const filePath = path3.join(this.SERVICES_DIR, file);
-            const stat = await fs2.stat(filePath);
+            const stat = await fs3.stat(filePath);
             if (stat.isFile() && (file.endsWith(".py") || file.endsWith(".sh"))) {
-              await fs2.chmod(filePath, 493);
+              await fs3.chmod(filePath, 493);
             }
           }
           await this.saveVersion();
@@ -492,11 +528,11 @@ var init_service_installer = __esm({
        */
       static async isInstalled() {
         try {
-          const exists = await fs2.pathExists(this.SERVICES_DIR);
+          const exists = await fs3.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return false;
           }
-          const files = await fs2.readdir(this.SERVICES_DIR);
+          const files = await fs3.readdir(this.SERVICES_DIR);
           return files.length > 0;
         } catch {
           return false;
@@ -519,11 +555,11 @@ var init_service_installer = __esm({
        */
       static async listServices() {
         try {
-          const exists = await fs2.pathExists(this.SERVICES_DIR);
+          const exists = await fs3.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return [];
           }
-          const files = await fs2.readdir(this.SERVICES_DIR);
+          const files = await fs3.readdir(this.SERVICES_DIR);
           return files.filter((file) => file.endsWith(".py") || file.endsWith(".sh"));
         } catch {
           return [];
@@ -534,9 +570,9 @@ var init_service_installer = __esm({
        */
       static async uninstall() {
         try {
-          const exists = await fs2.pathExists(this.SERVICES_DIR);
+          const exists = await fs3.pathExists(this.SERVICES_DIR);
           if (exists) {
-            await fs2.remove(this.SERVICES_DIR);
+            await fs3.remove(this.SERVICES_DIR);
             console.log("\u2713 Services uninstalled");
           }
         } catch (error) {
@@ -1112,17 +1148,17 @@ async function ensureHooksConfig(baseDir) {
   try {
     const configDir = path3.join(baseDir, ".juno_task");
     const configPath = path3.join(configDir, "config.json");
-    await fs2.ensureDir(configDir);
-    const configExists = await fs2.pathExists(configPath);
+    await fs3.ensureDir(configDir);
+    const configExists = await fs3.pathExists(configPath);
     const allHookTypes = getDefaultHooks();
     if (!configExists) {
       const defaultConfig = {
         ...DEFAULT_CONFIG,
         hooks: allHookTypes
       };
-      await fs2.writeJson(configPath, defaultConfig, { spaces: 2 });
+      await fs3.writeJson(configPath, defaultConfig, { spaces: 2 });
     } else {
-      const existingConfig = await fs2.readJson(configPath);
+      const existingConfig = await fs3.readJson(configPath);
       let needsUpdate = false;
       if (!existingConfig.hooks) {
         existingConfig.hooks = allHookTypes;
@@ -1140,7 +1176,7 @@ async function ensureHooksConfig(baseDir) {
         needsUpdate = true;
       }
       if (needsUpdate) {
-        await fs2.writeJson(configPath, existingConfig, { spaces: 2 });
+        await fs3.writeJson(configPath, existingConfig, { spaces: 2 });
       }
     }
   } catch (error) {
@@ -1750,6 +1786,12 @@ ${helpText}
           }
         }
         if (options.maxIterations !== void 0) {
+          if (Number.isNaN(options.maxIterations)) {
+            throw new ValidationError(
+              "Max iterations must be a valid number",
+              ["Use -1 for unlimited iterations", "Use positive integers like 1, 5, or 10", "Example: -i 5"]
+            );
+          }
           if (options.maxIterations !== -1 && options.maxIterations < 1) {
             throw new ValidationError(
               "Max iterations must be -1 (unlimited) or a positive number",
@@ -1758,8 +1800,8 @@ ${helpText}
           }
         }
         if (options.cwd) {
-          const fs21 = await import('fs-extra');
-          if (!await fs21.pathExists(options.cwd)) {
+          const fs22 = await import('fs-extra');
+          if (!await fs22.pathExists(options.cwd)) {
             throw new ValidationError(
               `Working directory does not exist: ${options.cwd}`,
               ["Verify the path exists", "Use absolute paths to avoid ambiguity"]
@@ -3843,8 +3885,8 @@ var init_engine = __esm({
         if (!request.workingDirectory?.trim()) {
           throw new Error("Working directory is required");
         }
-        if (request.maxIterations < -1 || request.maxIterations === 0) {
-          throw new Error("Max iterations must be positive or -1 for unlimited");
+        if (Number.isNaN(request.maxIterations) || request.maxIterations < -1 || request.maxIterations === 0) {
+          throw new Error("Max iterations must be a positive number or -1 for unlimited");
         }
       }
       /**
@@ -4854,7 +4896,7 @@ var init_config2 = __esm({
           return cached;
         }
         try {
-          const configContent = await fs2.readFile(configPath, "utf-8");
+          const configContent = await fs3.readFile(configPath, "utf-8");
           const config = JSON.parse(configContent);
           this.validateConfig(config);
           const resolvedConfig = this.resolveConfigPaths(config, path3.dirname(configPath));
@@ -4876,7 +4918,7 @@ var init_config2 = __esm({
         const rootDir = path3.parse(currentDir).root;
         while (currentDir !== rootDir) {
           const configPath = path3.join(currentDir, ".juno_task", "mcp.json");
-          if (await fs2.pathExists(configPath)) {
+          if (await fs3.pathExists(configPath)) {
             return configPath;
           }
           currentDir = path3.dirname(currentDir);
@@ -5062,7 +5104,7 @@ var init_logger = __esm({
        * Matches Python's generate_log_file function
        */
       async initialize(subagent = "mcp") {
-        await fs2.ensureDir(this.logDirectory);
+        await fs3.ensureDir(this.logDirectory);
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T");
         const dateStr = timestamp[0];
         const timeStr = timestamp[1].split("-")[0].substring(0, 6);
@@ -5071,7 +5113,7 @@ var init_logger = __esm({
         this.logFilePath = path3__default.join(this.logDirectory, logFileName);
         const header = `# Juno-Task TypeScript Log - Started ${(/* @__PURE__ */ new Date()).toISOString()}
 `;
-        await fs2.writeFile(this.logFilePath, header);
+        await fs3.writeFile(this.logFilePath, header);
       }
       /**
        * Format log message matching Python version format
@@ -5089,7 +5131,7 @@ var init_logger = __esm({
         if (!this.logFilePath) {
           throw new Error("Logger not initialized. Call initialize() first.");
         }
-        await fs2.appendFile(this.logFilePath, message);
+        await fs3.appendFile(this.logFilePath, message);
       }
       /**
        * Log message at specified level
@@ -7100,7 +7142,7 @@ var init_shell_backend = __esm({
         const timestamp = now.getFullYear().toString() + (now.getMonth() + 1).toString().padStart(2, "0") + now.getDate().toString().padStart(2, "0") + "_" + now.getHours().toString().padStart(2, "0") + now.getMinutes().toString().padStart(2, "0") + now.getSeconds().toString().padStart(2, "0");
         const logDir = path3.join(this.config.workingDirectory, ".juno_task", "logs");
         try {
-          await fs2.ensureDir(logDir);
+          await fs3.ensureDir(logDir);
         } catch (error) {
           if (this.config?.debug) {
             engineLogger.warn(`Failed to create log directory: ${error instanceof Error ? error.message : String(error)}`);
@@ -7125,7 +7167,7 @@ var init_shell_backend = __esm({
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
           const logEntry = `[${timestamp}] ${message}
 `;
-          await fs2.appendFile(this.logFilePath, logEntry, "utf-8");
+          await fs3.appendFile(this.logFilePath, logEntry, "utf-8");
         } catch (error) {
           if (this.config?.debug) {
             engineLogger.warn(`Failed to write to log file: ${error instanceof Error ? error.message : String(error)}`);
@@ -7199,6 +7241,7 @@ var init_shell_backend = __esm({
         return new Promise(async (resolve9, reject) => {
           const startTime = Date.now();
           const isPython = scriptPath.endsWith(".py");
+          const isGemini = subagentType === "gemini";
           const env2 = {
             ...process.env,
             ...this.config.environment,
@@ -7209,6 +7252,9 @@ var init_shell_backend = __esm({
             JUNO_ITERATION: String(request.arguments?.iteration || 1),
             JUNO_TOOL_ID: toolId
           };
+          if (isGemini) {
+            env2.GEMINI_OUTPUT_FORMAT = env2.GEMINI_OUTPUT_FORMAT || "stream-json";
+          }
           let captureDir = null;
           let capturePath = null;
           if (subagentType === "claude") {
@@ -7230,6 +7276,9 @@ var init_shell_backend = __esm({
           if (isPython && request.arguments?.model) {
             args.push("-m", request.arguments.model);
           }
+          if (isPython && isGemini) {
+            args.push("--output-format", env2.GEMINI_OUTPUT_FORMAT || "stream-json");
+          }
           if (isPython && request.arguments?.agents) {
             args.push("--agents", request.arguments.agents);
           }
@@ -12774,12 +12823,18 @@ async function mainCommandHandler(args, options, command) {
       console.error(chalk15.red("\n\u274C Error: --allowed-tools and --append-allowed-tools are mutually exclusive. Use one or the other."));
       process.exit(1);
     }
+    if (options.maxIterations !== void 0 && Number.isNaN(options.maxIterations)) {
+      throw new ValidationError(
+        "Max iterations must be a valid number",
+        ["Use -1 for unlimited iterations", "Use positive integers like 1, 5, or 10", "Example: -i 5"]
+      );
+    }
     const executionRequest = createExecutionRequest({
       instruction,
       subagent: options.subagent,
       backend: selectedBackend,
       workingDirectory: config.workingDirectory,
-      maxIterations: options.maxIterations || config.defaultMaxIterations,
+      maxIterations: options.maxIterations ?? config.defaultMaxIterations,
       model: options.model || config.defaultModel,
       agents: options.agents,
       tools: options.tools,
@@ -12944,7 +12999,7 @@ var init_main = __esm({
             return await this.collectInteractivePrompt();
           } else {
             const defaultPromptPath = path3.join(process.cwd(), ".juno_task", "prompt.md");
-            if (await fs2.pathExists(defaultPromptPath)) {
+            if (await fs3.pathExists(defaultPromptPath)) {
               console.error(chalk15.blue(`\u{1F4C4} Using default prompt: ${chalk15.cyan(".juno_task/prompt.md")}`));
               return await this.loadPromptFromFile(defaultPromptPath);
             } else {
@@ -12972,7 +13027,7 @@ var init_main = __esm({
         }
         try {
           const resolvedPath = path3.resolve(prompt);
-          return await fs2.pathExists(resolvedPath);
+          return await fs3.pathExists(resolvedPath);
         } catch {
           return false;
         }
@@ -12980,7 +13035,7 @@ var init_main = __esm({
       async loadPromptFromFile(filePath) {
         try {
           const resolvedPath = path3.resolve(filePath);
-          const content = await fs2.readFile(resolvedPath, "utf-8");
+          const content = await fs3.readFile(resolvedPath, "utf-8");
           if (!content.trim()) {
             throw new FileSystemError(
               "Prompt file is empty",
@@ -13302,6 +13357,342 @@ var init_main = __esm({
   }
 });
 
+// src/utils/script-installer.ts
+var script_installer_exports = {};
+__export(script_installer_exports, {
+  ScriptInstaller: () => ScriptInstaller
+});
+var ScriptInstaller;
+var init_script_installer = __esm({
+  "src/utils/script-installer.ts"() {
+    init_version();
+    ScriptInstaller = class {
+      /**
+       * Scripts that should be auto-installed if missing
+       * These are critical scripts that users expect to be available
+       */
+      /**
+       * Required scripts include both standalone scripts and their dependencies.
+       * kanban.sh depends on install_requirements.sh for Python venv setup.
+       * Slack integration scripts allow fetching tasks from Slack and responding.
+       */
+      static REQUIRED_SCRIPTS = [
+        "run_until_completion.sh",
+        "kanban.sh",
+        "install_requirements.sh",
+        // Required by kanban.sh for Python venv creation
+        // Slack integration scripts
+        "slack_state.py",
+        // State management for Slack integration
+        "slack_fetch.py",
+        // Core logic for fetching Slack messages
+        "slack_fetch.sh",
+        // Wrapper script for Slack fetch
+        "slack_respond.py",
+        // Core logic for sending responses to Slack
+        "slack_respond.sh"
+        // Wrapper script for Slack respond
+      ];
+      /**
+       * Get the templates scripts directory from the package
+       */
+      static getPackageScriptsDir() {
+        const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+          path3.join(__dirname2, "..", "..", "templates", "scripts"),
+          // dist (production)
+          path3.join(__dirname2, "..", "templates", "scripts")
+          // src (development)
+        ];
+        for (const scriptsPath of candidates) {
+          if (fs3.existsSync(scriptsPath)) {
+            return scriptsPath;
+          }
+        }
+        if (process.env.JUNO_CODE_DEBUG === "1") {
+          console.error("[DEBUG] ScriptInstaller: Could not find templates/scripts directory");
+          console.error("[DEBUG] Tried:", candidates);
+        }
+        return null;
+      }
+      /**
+       * Check if a specific script exists in the project's .juno_task/scripts/ directory
+       */
+      static async scriptExists(projectDir, scriptName) {
+        const scriptPath = path3.join(projectDir, ".juno_task", "scripts", scriptName);
+        return fs3.pathExists(scriptPath);
+      }
+      /**
+       * Install a specific script to the project's .juno_task/scripts/ directory
+       * @param projectDir - The project root directory
+       * @param scriptName - Name of the script to install (e.g., 'run_until_completion.sh')
+       * @param silent - If true, suppresses console output
+       * @returns true if script was installed, false if installation was skipped or failed
+       */
+      static async installScript(projectDir, scriptName, silent = false) {
+        try {
+          const packageScriptsDir = this.getPackageScriptsDir();
+          if (!packageScriptsDir) {
+            if (!silent && process.env.JUNO_CODE_DEBUG === "1") {
+              console.error("[DEBUG] ScriptInstaller: Package scripts directory not found");
+            }
+            return false;
+          }
+          const sourcePath = path3.join(packageScriptsDir, scriptName);
+          if (!await fs3.pathExists(sourcePath)) {
+            if (!silent && process.env.JUNO_CODE_DEBUG === "1") {
+              console.error(`[DEBUG] ScriptInstaller: Source script not found: ${sourcePath}`);
+            }
+            return false;
+          }
+          const destDir = path3.join(projectDir, ".juno_task", "scripts");
+          await fs3.ensureDir(destDir);
+          const destPath = path3.join(destDir, scriptName);
+          await fs3.copy(sourcePath, destPath, { overwrite: true });
+          if (scriptName.endsWith(".sh") || scriptName.endsWith(".py")) {
+            await fs3.chmod(destPath, 493);
+          }
+          if (!silent) {
+            console.log(`\u2713 Installed script: ${scriptName} to .juno_task/scripts/`);
+          }
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error(`[DEBUG] ScriptInstaller: Installed ${scriptName} to ${destPath}`);
+          }
+          return true;
+        } catch (error) {
+          if (!silent && process.env.JUNO_CODE_DEBUG === "1") {
+            console.error(`[DEBUG] ScriptInstaller: Failed to install ${scriptName}:`, error);
+          }
+          return false;
+        }
+      }
+      /**
+       * Check which required scripts are missing from the project
+       * @param projectDir - The project root directory
+       * @returns Array of missing script names
+       */
+      static async getMissingScripts(projectDir) {
+        const missing = [];
+        for (const script of this.REQUIRED_SCRIPTS) {
+          if (!await this.scriptExists(projectDir, script)) {
+            missing.push(script);
+          }
+        }
+        return missing;
+      }
+      /**
+       * Auto-install any missing required scripts
+       * This should be called on CLI startup for initialized projects
+       * @param projectDir - The project root directory
+       * @param silent - If true, suppresses console output
+       * @returns true if any scripts were installed
+       */
+      static async autoInstallMissing(projectDir, silent = true) {
+        try {
+          const junoTaskDir = path3.join(projectDir, ".juno_task");
+          if (!await fs3.pathExists(junoTaskDir)) {
+            return false;
+          }
+          const missing = await this.getMissingScripts(projectDir);
+          if (missing.length === 0) {
+            return false;
+          }
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error(`[DEBUG] ScriptInstaller: Missing scripts: ${missing.join(", ")}`);
+          }
+          let installedAny = false;
+          for (const script of missing) {
+            const installed = await this.installScript(projectDir, script, silent);
+            if (installed) {
+              installedAny = true;
+            }
+          }
+          if (installedAny && !silent) {
+            console.log(`\u2713 Auto-installed ${missing.length} missing script(s)`);
+          }
+          return installedAny;
+        } catch (error) {
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error("[DEBUG] ScriptInstaller: autoInstallMissing error:", error);
+          }
+          return false;
+        }
+      }
+      /**
+       * Update a script if the package version is newer (by content comparison)
+       * @param projectDir - The project root directory
+       * @param scriptName - Name of the script to update
+       * @param silent - If true, suppresses console output
+       * @returns true if script was updated
+       */
+      static async updateScriptIfNewer(projectDir, scriptName, silent = true) {
+        try {
+          const packageScriptsDir = this.getPackageScriptsDir();
+          if (!packageScriptsDir) {
+            return false;
+          }
+          const sourcePath = path3.join(packageScriptsDir, scriptName);
+          const destPath = path3.join(projectDir, ".juno_task", "scripts", scriptName);
+          if (!await fs3.pathExists(destPath)) {
+            return this.installScript(projectDir, scriptName, silent);
+          }
+          const [sourceContent, destContent] = await Promise.all([
+            fs3.readFile(sourcePath, "utf-8"),
+            fs3.readFile(destPath, "utf-8")
+          ]);
+          if (sourceContent !== destContent) {
+            await fs3.copy(sourcePath, destPath, { overwrite: true });
+            if (scriptName.endsWith(".sh") || scriptName.endsWith(".py")) {
+              await fs3.chmod(destPath, 493);
+            }
+            if (!silent) {
+              console.log(`\u2713 Updated script: ${scriptName}`);
+            }
+            if (process.env.JUNO_CODE_DEBUG === "1") {
+              console.error(`[DEBUG] ScriptInstaller: Updated ${scriptName} (content changed)`);
+            }
+            return true;
+          }
+          return false;
+        } catch (error) {
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error(`[DEBUG] ScriptInstaller: updateScriptIfNewer error for ${scriptName}:`, error);
+          }
+          return false;
+        }
+      }
+      /**
+       * Get the path to a script in the project's .juno_task/scripts/ directory
+       */
+      static getScriptPath(projectDir, scriptName) {
+        return path3.join(projectDir, ".juno_task", "scripts", scriptName);
+      }
+      /**
+       * List all required scripts and their installation status
+       */
+      static async listRequiredScripts(projectDir) {
+        const results = [];
+        for (const script of this.REQUIRED_SCRIPTS) {
+          results.push({
+            name: script,
+            installed: await this.scriptExists(projectDir, script)
+          });
+        }
+        return results;
+      }
+      /**
+       * Get scripts that need updates based on content comparison
+       * @param projectDir - The project root directory
+       * @returns Array of script names that have different content from package version
+       */
+      static async getOutdatedScripts(projectDir) {
+        const outdated = [];
+        const packageScriptsDir = this.getPackageScriptsDir();
+        if (!packageScriptsDir) {
+          return outdated;
+        }
+        for (const script of this.REQUIRED_SCRIPTS) {
+          const sourcePath = path3.join(packageScriptsDir, script);
+          const destPath = path3.join(projectDir, ".juno_task", "scripts", script);
+          if (!await fs3.pathExists(sourcePath)) {
+            continue;
+          }
+          if (!await fs3.pathExists(destPath)) {
+            continue;
+          }
+          try {
+            const [sourceContent, destContent] = await Promise.all([
+              fs3.readFile(sourcePath, "utf-8"),
+              fs3.readFile(destPath, "utf-8")
+            ]);
+            if (sourceContent !== destContent) {
+              outdated.push(script);
+            }
+          } catch {
+            outdated.push(script);
+          }
+        }
+        return outdated;
+      }
+      /**
+       * Check if any scripts need installation or update
+       * @param projectDir - The project root directory
+       * @returns true if any scripts need to be installed or updated
+       */
+      static async needsUpdate(projectDir) {
+        try {
+          const junoTaskDir = path3.join(projectDir, ".juno_task");
+          if (!await fs3.pathExists(junoTaskDir)) {
+            return false;
+          }
+          const missing = await this.getMissingScripts(projectDir);
+          if (missing.length > 0) {
+            return true;
+          }
+          const outdated = await this.getOutdatedScripts(projectDir);
+          return outdated.length > 0;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Automatically update scripts - installs missing AND updates outdated scripts
+       * Similar to ServiceInstaller.autoUpdate(), this ensures project scripts
+       * are always in sync with the package version.
+       *
+       * This should be called on every CLI run to ensure scripts are up-to-date.
+       * @param projectDir - The project root directory
+       * @param silent - If true, suppresses console output
+       * @returns true if any scripts were installed or updated
+       */
+      static async autoUpdate(projectDir, silent = true) {
+        try {
+          const debug = process.env.JUNO_CODE_DEBUG === "1";
+          const junoTaskDir = path3.join(projectDir, ".juno_task");
+          if (!await fs3.pathExists(junoTaskDir)) {
+            return false;
+          }
+          const missing = await this.getMissingScripts(projectDir);
+          const outdated = await this.getOutdatedScripts(projectDir);
+          if (debug) {
+            if (missing.length > 0) {
+              console.error(`[DEBUG] ScriptInstaller: Missing scripts: ${missing.join(", ")}`);
+            }
+            if (outdated.length > 0) {
+              console.error(`[DEBUG] ScriptInstaller: Outdated scripts: ${outdated.join(", ")}`);
+            }
+          }
+          if (missing.length === 0 && outdated.length === 0) {
+            return false;
+          }
+          const scriptsToUpdate = [.../* @__PURE__ */ new Set([...missing, ...outdated])];
+          let updatedAny = false;
+          for (const script of scriptsToUpdate) {
+            const installed = await this.installScript(projectDir, script, silent);
+            if (installed) {
+              updatedAny = true;
+            }
+          }
+          if (updatedAny) {
+            if (debug) {
+              console.error(`[DEBUG] ScriptInstaller: Updated ${scriptsToUpdate.length} script(s)`);
+            }
+            if (!silent) {
+              console.log(`\u2713 Updated ${scriptsToUpdate.length} script(s) in .juno_task/scripts/`);
+            }
+          }
+          return updatedAny;
+        } catch (error) {
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error("[DEBUG] ScriptInstaller: autoUpdate error:", error);
+          }
+          return false;
+        }
+      }
+    };
+  }
+});
+
 // src/utils/startup-validation.ts
 var startup_validation_exports = {};
 __export(startup_validation_exports, {
@@ -13392,7 +13783,7 @@ async function validateJSONFile(configSchema, baseDir) {
   const warnings = [];
   const filePath = path3__default.join(baseDir, configSchema.file);
   try {
-    const exists = await fs2.pathExists(filePath);
+    const exists = await fs3.pathExists(filePath);
     if (!exists) {
       if (configSchema.required) {
         errors.push({
@@ -13415,7 +13806,7 @@ async function validateJSONFile(configSchema, baseDir) {
       return { isValid: !configSchema.required, errors, warnings };
     }
     try {
-      await fs2.access(filePath, fs2.constants.R_OK);
+      await fs3.access(filePath, fs3.constants.R_OK);
     } catch (accessError) {
       errors.push({
         file: configSchema.file,
@@ -13431,7 +13822,7 @@ async function validateJSONFile(configSchema, baseDir) {
     }
     let jsonData;
     try {
-      const fileContent = await fs2.readFile(filePath, "utf8");
+      const fileContent = await fs3.readFile(filePath, "utf8");
       jsonData = JSON.parse(fileContent);
     } catch (parseError) {
       const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
@@ -13566,7 +13957,7 @@ function displayValidationResults(result) {
 }
 async function logValidationResults(result, baseDir = process.cwd()) {
   const logDir = path3__default.join(baseDir, ".juno_task", "logs");
-  await fs2.ensureDir(logDir);
+  await fs3.ensureDir(logDir);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const logFile = path3__default.join(logDir, `startup-validation-${timestamp}.log`);
   const logContent = [
@@ -13609,7 +14000,7 @@ async function logValidationResults(result, baseDir = process.cwd()) {
       logContent.push(``);
     }
   }
-  await fs2.writeFile(logFile, logContent.join("\n"));
+  await fs3.writeFile(logFile, logContent.join("\n"));
   return logFile;
 }
 async function validateStartupConfigs(baseDir = process.cwd(), verbose = false) {
@@ -13943,7 +14334,7 @@ var TemplateEngine = class {
     let overallError;
     try {
       if (!options.dryRun) {
-        await fs2.ensureDir(targetDirectory);
+        await fs3.ensureDir(targetDirectory);
       }
       for (const template of templates) {
         try {
@@ -15293,7 +15684,7 @@ This directory contains specification documents for your project.
     const fileName = this.getTemplateFileName(template);
     const targetPath = path3.join(targetDirectory, fileName);
     try {
-      const fileExists = await fs2.pathExists(targetPath);
+      const fileExists = await fs3.pathExists(targetPath);
       if (fileExists && !options.force && options.onConflict !== "overwrite") {
         return {
           path: targetPath,
@@ -15315,10 +15706,10 @@ This directory contains specification documents for your project.
       }
       if (options.createBackup && fileExists) {
         const backupPath = `${targetPath}.backup.${Date.now()}`;
-        await fs2.copy(targetPath, backupPath);
+        await fs3.copy(targetPath, backupPath);
       }
-      await fs2.ensureDir(path3.dirname(targetPath));
-      await fs2.writeFile(targetPath, renderedContent, "utf8");
+      await fs3.ensureDir(path3.dirname(targetPath));
+      await fs3.writeFile(targetPath, renderedContent, "utf8");
       return {
         path: targetPath,
         content: renderedContent,
@@ -15582,7 +15973,7 @@ var SimpleInitTUI = class {
   }
   async confirmSave(targetDirectory) {
     const junoTaskPath = path3.join(targetDirectory, ".juno_task");
-    if (await fs2.pathExists(junoTaskPath)) {
+    if (await fs3.pathExists(junoTaskPath)) {
       console.log(chalk15.yellow("   \u26A0\uFE0F  .juno_task directory already exists"));
       console.log(chalk15.gray("   Would you like to:"));
       console.log(chalk15.gray("   1) Override existing files"));
@@ -15627,16 +16018,16 @@ var SimpleProjectGenerator = class {
   async generate() {
     const { targetDirectory, variables, force } = this.context;
     console.log(chalk15.blue("\u{1F4C1} Creating project directory..."));
-    await fs2.ensureDir(targetDirectory);
+    await fs3.ensureDir(targetDirectory);
     const junoTaskDir = path3.join(targetDirectory, ".juno_task");
-    const junoTaskExists = await fs2.pathExists(junoTaskDir);
+    const junoTaskExists = await fs3.pathExists(junoTaskDir);
     if (junoTaskExists && !force) {
       throw new ValidationError(
         "Project already initialized. Directory .juno_task already exists.",
         ["Use --force flag to overwrite existing files", "Choose a different directory"]
       );
     }
-    await fs2.ensureDir(junoTaskDir);
+    await fs3.ensureDir(junoTaskDir);
     console.log(chalk15.blue("\u2699\uFE0F Creating project configuration..."));
     await this.createConfigFile(junoTaskDir, targetDirectory);
     console.log(chalk15.blue("\u{1F527} Setting up MCP configuration..."));
@@ -15670,21 +16061,21 @@ var SimpleProjectGenerator = class {
     const promptContent = await templateEngine.render(promptTemplate, templateContext);
     const initContent = await templateEngine.render(initTemplate, templateContext);
     const implementContent = await templateEngine.render(implementTemplate, templateContext);
-    await fs2.writeFile(path3.join(junoTaskDir, "prompt.md"), promptContent);
-    await fs2.writeFile(path3.join(junoTaskDir, "init.md"), initContent);
-    await fs2.writeFile(path3.join(junoTaskDir, "implement.md"), implementContent);
+    await fs3.writeFile(path3.join(junoTaskDir, "prompt.md"), promptContent);
+    await fs3.writeFile(path3.join(junoTaskDir, "init.md"), initContent);
+    await fs3.writeFile(path3.join(junoTaskDir, "implement.md"), implementContent);
     const userFeedbackTemplate = templateEngine.getBuiltInTemplate("USER_FEEDBACK.md");
     if (userFeedbackTemplate) {
       const userFeedbackContent = await templateEngine.render(userFeedbackTemplate, templateContext);
-      await fs2.writeFile(path3.join(junoTaskDir, "USER_FEEDBACK.md"), userFeedbackContent);
+      await fs3.writeFile(path3.join(junoTaskDir, "USER_FEEDBACK.md"), userFeedbackContent);
     }
     const planTemplate = templateEngine.getBuiltInTemplate("plan.md");
     if (planTemplate) {
       const planContent = await templateEngine.render(planTemplate, templateContext);
-      await fs2.writeFile(path3.join(junoTaskDir, "plan.md"), planContent);
+      await fs3.writeFile(path3.join(junoTaskDir, "plan.md"), planContent);
     }
     const specsDir = path3.join(junoTaskDir, "specs");
-    await fs2.ensureDir(specsDir);
+    await fs3.ensureDir(specsDir);
     const specsReadmeContent = `# Project Specifications
 
 This directory contains detailed specifications for the project components.
@@ -15701,7 +16092,7 @@ This directory contains detailed specifications for the project components.
 - Avoid conflicts with existing file names
 - Use \`.md\` extension for all specification files
 `;
-    await fs2.writeFile(path3.join(specsDir, "README.md"), specsReadmeContent);
+    await fs3.writeFile(path3.join(specsDir, "README.md"), specsReadmeContent);
     const requirementsContent = `# Requirements Specification
 
 ## Functional Requirements
@@ -15748,7 +16139,7 @@ This directory contains detailed specifications for the project components.
 - Code quality: Clean, maintainable codebase
 - Documentation: Complete and accurate documentation
 `;
-    await fs2.writeFile(path3.join(specsDir, "requirements.md"), requirementsContent);
+    await fs3.writeFile(path3.join(specsDir, "requirements.md"), requirementsContent);
     const architectureContent = `# Architecture Specification
 
 ## System Overview
@@ -15830,7 +16221,7 @@ This project uses AI-assisted development with juno-code to achieve: ${variables
 - Performance monitoring
 - Security best practices
 `;
-    await fs2.writeFile(path3.join(specsDir, "architecture.md"), architectureContent);
+    await fs3.writeFile(path3.join(specsDir, "architecture.md"), architectureContent);
     const claudeContent = `# Claude Development Session Learnings
 
 ## Project Overview
@@ -15902,7 +16293,7 @@ This file will be updated as development progresses to track:
 - Solutions to complex problems
 - Performance improvements and optimizations
 `;
-    await fs2.writeFile(path3.join(targetDirectory, "CLAUDE.md"), claudeContent);
+    await fs3.writeFile(path3.join(targetDirectory, "CLAUDE.md"), claudeContent);
     const agentsContent = `# AI Agent Selection and Performance
 
 ## Available Agents
@@ -15966,7 +16357,7 @@ Track agent performance for:
 4. **Feedback Loop**: Provide feedback to improve agent performance
 5. **Performance Monitoring**: Track and optimize agent usage
 `;
-    await fs2.writeFile(path3.join(targetDirectory, "AGENTS.md"), agentsContent);
+    await fs3.writeFile(path3.join(targetDirectory, "AGENTS.md"), agentsContent);
     const readmeContent = `# ${variables.PROJECT_NAME}
 
 ${variables.DESCRIPTION}
@@ -16063,7 +16454,7 @@ ${variables.GIT_URL}` : ""}
 Created with juno-code on ${variables.CURRENT_DATE}
 ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
 `;
-    await fs2.writeFile(path3.join(targetDirectory, "README.md"), readmeContent);
+    await fs3.writeFile(path3.join(targetDirectory, "README.md"), readmeContent);
     console.log(chalk15.blue("\u{1F4E6} Installing utility scripts..."));
     await this.copyScriptsFromTemplates(junoTaskDir);
     console.log(chalk15.blue("\u{1F40D} Installing Python requirements..."));
@@ -16115,7 +16506,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       hooks: getDefaultHooks()
     };
     const configPath = path3.join(junoTaskDir, "config.json");
-    await fs2.writeFile(configPath, JSON.stringify(configContent, null, 2));
+    await fs3.writeFile(configPath, JSON.stringify(configContent, null, 2));
     console.log(chalk15.green(`   \u2713 Created .juno_task/config.json with ${this.context.subagent} as default subagent`));
   }
   async createMcpFile(junoTaskDir, targetDirectory) {
@@ -16169,7 +16560,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       }
     };
     const mcpPath = path3.join(junoTaskDir, "mcp.json");
-    await fs2.writeFile(mcpPath, JSON.stringify(mcpContent, null, 2));
+    await fs3.writeFile(mcpPath, JSON.stringify(mcpContent, null, 2));
     console.log(chalk15.green(`   \u2713 Created .juno_task/mcp.json with roundtable-ai server configuration`));
   }
   getDefaultModelForSubagent(subagent) {
@@ -16188,7 +16579,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
   async copyScriptsFromTemplates(junoTaskDir) {
     try {
       const scriptsDir = path3.join(junoTaskDir, "scripts");
-      await fs2.ensureDir(scriptsDir);
+      await fs3.ensureDir(scriptsDir);
       const __filename2 = fileURLToPath(import.meta.url);
       const __dirname2 = path3.dirname(__filename2);
       let templatesScriptsDir;
@@ -16199,11 +16590,11 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       } else {
         templatesScriptsDir = path3.join(__dirname2, "../../templates/scripts");
       }
-      if (!await fs2.pathExists(templatesScriptsDir)) {
+      if (!await fs3.pathExists(templatesScriptsDir)) {
         console.log(chalk15.yellow("   \u26A0\uFE0F  Template scripts directory not found, skipping script installation"));
         return;
       }
-      const scriptFiles = await fs2.readdir(templatesScriptsDir);
+      const scriptFiles = await fs3.readdir(templatesScriptsDir);
       if (scriptFiles.length === 0) {
         console.log(chalk15.gray("   \u2139\uFE0F  No template scripts found to install"));
         return;
@@ -16212,11 +16603,11 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       for (const scriptFile of scriptFiles) {
         const sourcePath = path3.join(templatesScriptsDir, scriptFile);
         const destPath = path3.join(scriptsDir, scriptFile);
-        const stats = await fs2.stat(sourcePath);
+        const stats = await fs3.stat(sourcePath);
         if (stats.isFile()) {
-          await fs2.copy(sourcePath, destPath);
+          await fs3.copy(sourcePath, destPath);
           if (scriptFile.endsWith(".sh")) {
-            await fs2.chmod(destPath, 493);
+            await fs3.chmod(destPath, 493);
           }
           copiedCount++;
           console.log(chalk15.green(`   \u2713 Installed script: ${scriptFile}`));
@@ -16239,7 +16630,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
     try {
       const scriptsDir = path3.join(junoTaskDir, "scripts");
       const installScript = path3.join(scriptsDir, "install_requirements.sh");
-      if (!await fs2.pathExists(installScript)) {
+      if (!await fs3.pathExists(installScript)) {
         console.log(chalk15.yellow("   \u26A0\uFE0F  install_requirements.sh not found, skipping Python dependencies installation"));
         console.log(chalk15.gray("   You can install dependencies manually: juno-kanban, roundtable-ai"));
         return;
@@ -16536,20 +16927,20 @@ init_types();
 async function loadInitPrompt(directory) {
   const junoTaskDir = path3.join(directory, ".juno_task");
   const initFile = path3.join(junoTaskDir, "init.md");
-  if (!await fs2.pathExists(junoTaskDir)) {
+  if (!await fs3.pathExists(junoTaskDir)) {
     throw new FileSystemError(
       'No .juno_task directory found. Run "juno-code init" first.',
       junoTaskDir
     );
   }
-  if (!await fs2.pathExists(initFile)) {
+  if (!await fs3.pathExists(initFile)) {
     throw new FileSystemError(
       "No init.md file found in .juno_task directory",
       initFile
     );
   }
   try {
-    const content = await fs2.readFile(initFile, "utf-8");
+    const content = await fs3.readFile(initFile, "utf-8");
     if (!content.trim()) {
       throw new FileSystemError(
         "init.md file is empty. Please add task instructions.",
@@ -17581,8 +17972,8 @@ Focus on ${request.intelligence === "basic" ? "basic functionality" : request.in
     for (const scenario of scenarios) {
       const testContent = await this.generateTestContent(request, scenario, template);
       const testFilePath = this.resolveTestFilePath(request, scenario);
-      await fs2.ensureDir(path3.dirname(testFilePath));
-      await fs2.writeFile(testFilePath, testContent);
+      await fs3.ensureDir(path3.dirname(testFilePath));
+      await fs3.writeFile(testFilePath, testContent);
       testFiles.push(testFilePath);
     }
     return testFiles;
@@ -17834,8 +18225,8 @@ var TestExecutionEngine = class {
   async collectCoverage(request) {
     const coverageFile = path3.join(request.workingDirectory, "coverage", "coverage-summary.json");
     try {
-      if (await fs2.pathExists(coverageFile)) {
-        const coverageData = await fs2.readJson(coverageFile);
+      if (await fs3.pathExists(coverageFile)) {
+        const coverageData = await fs3.readJson(coverageFile);
         return {
           lines: coverageData.total?.lines?.pct || 0,
           functions: coverageData.total?.functions?.pct || 0,
@@ -18018,8 +18409,8 @@ var TestReportEngine = class {
       suggestions: analysis.suggestions,
       recommendations: analysis.recommendations
     };
-    await fs2.ensureDir(path3.dirname(outputPath));
-    await fs2.writeJson(outputPath, report, { spaces: 2 });
+    await fs3.ensureDir(path3.dirname(outputPath));
+    await fs3.writeJson(outputPath, report, { spaces: 2 });
     return outputPath;
   }
   async generateHTMLReport(analysis, outputPath, includeVisualizations) {
@@ -18082,8 +18473,8 @@ var TestReportEngine = class {
 </body>
 </html>
     `.trim();
-    await fs2.ensureDir(path3.dirname(outputPath));
-    await fs2.writeFile(outputPath, html);
+    await fs3.ensureDir(path3.dirname(outputPath));
+    await fs3.writeFile(outputPath, html);
     return outputPath;
   }
   generateCharts(analysis) {
@@ -18140,8 +18531,8 @@ ${analysis.suggestions.map((suggestion) => `- ${suggestion}`).join("\n")}
 
 ${analysis.recommendations.map((rec) => `- ${rec}`).join("\n")}
     `.trim();
-    await fs2.ensureDir(path3.dirname(outputPath));
-    await fs2.writeFile(outputPath, markdown);
+    await fs3.ensureDir(path3.dirname(outputPath));
+    await fs3.writeFile(outputPath, markdown);
     return outputPath;
   }
   async displayConsoleReport(analysis) {
@@ -18481,16 +18872,16 @@ async function compactConfigFile(filePath, options = {}) {
     preserveDays = 30,
     preservePatterns = []
   } = options;
-  const originalContent = await fs2.readFile(filePath, "utf-8");
+  const originalContent = await fs3.readFile(filePath, "utf-8");
   const originalSize = originalContent.length;
   let backupPath = "";
   if (createBackup && !dryRun) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const ext = path3.extname(filePath);
     const basename11 = path3.basename(filePath, ext);
-    const dirname12 = path3.dirname(filePath);
-    backupPath = path3.join(dirname12, `${basename11}.backup.${timestamp}${ext}`);
-    await fs2.writeFile(backupPath, originalContent, "utf-8");
+    const dirname13 = path3.dirname(filePath);
+    backupPath = path3.join(dirname13, `${basename11}.backup.${timestamp}${ext}`);
+    await fs3.writeFile(backupPath, originalContent, "utf-8");
   }
   const compactionAnalysis = analyzeMarkdownStructure(originalContent);
   const compactedContent = compactMarkdownContent(
@@ -18505,7 +18896,7 @@ async function compactConfigFile(filePath, options = {}) {
   const compactedSize = finalContent.length;
   const reductionPercentage = Math.round((originalSize - compactedSize) / originalSize * 100);
   if (!dryRun) {
-    await fs2.writeFile(filePath, finalContent, "utf-8");
+    await fs3.writeFile(filePath, finalContent, "utf-8");
   }
   return {
     originalSize,
@@ -18635,7 +19026,7 @@ function formatFileSize(bytes) {
 }
 async function shouldCompactFile(filePath, sizeThresholdKB = 50, ageThresholdDays = 30) {
   try {
-    const stats = await fs2.stat(filePath);
+    const stats = await fs3.stat(filePath);
     const sizeKB = stats.size / 1024;
     if (sizeKB > sizeThresholdKB) {
       return true;
@@ -18657,19 +19048,19 @@ async function archiveResolvedIssues(options) {
     feedbackFile,
     archiveDir = path3.join(path3.dirname(feedbackFile), "archives"),
     openIssuesThreshold = 10} = options;
-  if (!await fs2.pathExists(feedbackFile)) {
+  if (!await fs3.pathExists(feedbackFile)) {
     throw new Error(`Feedback file does not exist: ${feedbackFile}`);
   }
-  const content = await fs2.readFile(feedbackFile, "utf-8");
+  const content = await fs3.readFile(feedbackFile, "utf-8");
   const parsed = parseUserFeedback(content);
   const warningsGenerated = [];
   if (parsed.openIssues.length > openIssuesThreshold) {
     const warning = `Found ${parsed.openIssues.length} open issues (threshold: ${openIssuesThreshold}). Consider reviewing and prioritizing.`;
     warningsGenerated.push(warning);
     const logFile = path3.join(path3.dirname(feedbackFile), "logs", "feedback-warnings.log");
-    await fs2.ensureDir(path3.dirname(logFile));
+    await fs3.ensureDir(path3.dirname(logFile));
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    await fs2.appendFile(logFile, `[${timestamp}] ${warning}
+    await fs3.appendFile(logFile, `[${timestamp}] ${warning}
 `);
   }
   if (parsed.resolvedIssues.length === 0) {
@@ -18686,10 +19077,10 @@ async function archiveResolvedIssues(options) {
   const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
   const archiveFile = path3.join(archiveDir, `USER_FEEDBACK_archive_${currentYear}.md`);
   {
-    await fs2.ensureDir(archiveDir);
+    await fs3.ensureDir(archiveDir);
     await appendToArchive(archiveFile, parsed.resolvedIssues);
     const compactedContent = generateCompactedFeedback(parsed.openIssues, parsed.metadata);
-    await fs2.writeFile(feedbackFile, compactedContent, "utf-8");
+    await fs3.writeFile(feedbackFile, compactedContent, "utf-8");
   }
   {
     console.log(chalk15.green(`\u2705 Archived ${parsed.resolvedIssues.length} resolved issues`));
@@ -18736,8 +19127,8 @@ function parseUserFeedback(content) {
 async function appendToArchive(archiveFile, resolvedIssues) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let archiveContent = "";
-  if (await fs2.pathExists(archiveFile)) {
-    archiveContent = await fs2.readFile(archiveFile, "utf-8");
+  if (await fs3.pathExists(archiveFile)) {
+    archiveContent = await fs3.readFile(archiveFile, "utf-8");
   } else {
     const year = path3.basename(archiveFile).match(/(\d{4})/)?.[1] || (/* @__PURE__ */ new Date()).getFullYear();
     archiveContent = `# User Feedback Archive ${year}
@@ -18771,7 +19162,7 @@ ${resolvedIssue}
       `- Last updated: ${timestamp}`
     );
   }
-  await fs2.writeFile(archiveFile, archiveContent, "utf-8");
+  await fs3.writeFile(archiveFile, archiveContent, "utf-8");
 }
 function generateCompactedFeedback(openIssues, metadata) {
   let content = metadata.trim() + "\n";
@@ -18796,15 +19187,15 @@ async function shouldArchive(feedbackFile, options = {}) {
     // 50KB
     lineCountThreshold = 500
   } = options;
-  if (!await fs2.pathExists(feedbackFile)) {
+  if (!await fs3.pathExists(feedbackFile)) {
     return {
       shouldArchive: false,
       reasons: [],
       stats: { openIssuesCount: 0, resolvedIssuesCount: 0, fileSizeBytes: 0, lineCount: 0 }
     };
   }
-  const content = await fs2.readFile(feedbackFile, "utf-8");
-  const stats = await fs2.stat(feedbackFile);
+  const content = await fs3.readFile(feedbackFile, "utf-8");
+  const stats = await fs3.stat(feedbackFile);
   const parsed = parseUserFeedback(content);
   const lineCount = content.split("\n").length;
   const reasons = [];
@@ -18878,16 +19269,16 @@ var EnhancedFeedbackFileManager = class {
     this.feedbackFile = feedbackFile;
   }
   async ensureExists() {
-    if (!await fs2.pathExists(this.feedbackFile)) {
+    if (!await fs3.pathExists(this.feedbackFile)) {
       await this.createInitialFile();
     }
   }
   async addFeedback(issue, testCriteria) {
     await this.ensureExists();
     try {
-      const content = await fs2.readFile(this.feedbackFile, "utf-8");
+      const content = await fs3.readFile(this.feedbackFile, "utf-8");
       const updatedContent = this.addIssueToContent(content, issue, testCriteria);
-      await fs2.writeFile(this.feedbackFile, updatedContent, "utf-8");
+      await fs3.writeFile(this.feedbackFile, updatedContent, "utf-8");
     } catch (error) {
       throw new ValidationError(
         `Failed to save feedback: ${error}`,
@@ -18900,12 +19291,12 @@ var EnhancedFeedbackFileManager = class {
    */
   async repairMalformedFile() {
     try {
-      const content = await fs2.readFile(this.feedbackFile, "utf-8");
+      const content = await fs3.readFile(this.feedbackFile, "utf-8");
       const hasOpenIssues = content.includes("<OPEN_ISSUES>");
       const hasClosingTag = content.includes("</OPEN_ISSUES>");
       if (!hasOpenIssues || !hasClosingTag) {
         const backupPath = this.feedbackFile + ".backup." + Date.now();
-        await fs2.writeFile(backupPath, content, "utf-8");
+        await fs3.writeFile(backupPath, content, "utf-8");
         const existingIssues = this.extractIssuesFromMalformedContent(content);
         await this.createInitialFile(existingIssues);
       }
@@ -18937,8 +19328,8 @@ List any features you'd like to see added or bugs you've encountered.
 
 <!-- Resolved issues will be moved here -->
 `;
-    await fs2.ensureDir(path3.dirname(this.feedbackFile));
-    await fs2.writeFile(this.feedbackFile, initialContent, "utf-8");
+    await fs3.ensureDir(path3.dirname(this.feedbackFile));
+    await fs3.writeFile(this.feedbackFile, initialContent, "utf-8");
   }
   addIssueToContent(content, issue, testCriteria) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -19054,17 +19445,17 @@ async function handleCompactCommand(subArgs, options) {
     if (subArgs.length > 0) {
       for (const filePath of subArgs) {
         const resolvedPath = path3.resolve(filePath);
-        if (await fs2.pathExists(resolvedPath)) {
+        if (await fs3.pathExists(resolvedPath)) {
           filesToCompact.push(resolvedPath);
         } else {
           console.warn(chalk15.yellow(`\u26A0\uFE0F  File not found: ${filePath}`));
         }
       }
     } else {
-      if (await fs2.pathExists(defaultClaudeFile)) {
+      if (await fs3.pathExists(defaultClaudeFile)) {
         filesToCompact.push(defaultClaudeFile);
       }
-      if (await fs2.pathExists(defaultAgentsFile)) {
+      if (await fs3.pathExists(defaultAgentsFile)) {
         filesToCompact.push(defaultAgentsFile);
       }
     }
@@ -19998,11 +20389,11 @@ var GitManager = class {
    */
   async updateJunoTaskConfig(gitUrl) {
     const configPath = path3.join(this.workingDirectory, ".juno_task", "init.md");
-    if (!await fs2.pathExists(configPath)) {
+    if (!await fs3.pathExists(configPath)) {
       return;
     }
     try {
-      let content = await fs2.readFile(configPath, "utf-8");
+      let content = await fs3.readFile(configPath, "utf-8");
       const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (frontmatterMatch) {
         let frontmatter = frontmatterMatch[1];
@@ -20023,7 +20414,7 @@ GIT_URL: ${gitUrl}
 `;
         content = frontmatter + content;
       }
-      await fs2.writeFile(configPath, content, "utf-8");
+      await fs3.writeFile(configPath, content, "utf-8");
     } catch (error) {
       console.warn(`Warning: Failed to update juno-code configuration: ${error}`);
     }
@@ -20955,7 +21346,7 @@ var LogViewer = ({
 init_types();
 async function exportLogs(logger2, filepath, options) {
   try {
-    const fs21 = await import('fs-extra');
+    const fs22 = await import('fs-extra');
     let entries = logger2.getRecentEntries(options.tail || 1e3);
     if (options.level) {
       const level = LogLevel[options.level.toUpperCase()];
@@ -20985,7 +21376,7 @@ async function exportLogs(logger2, filepath, options) {
       },
       entries
     };
-    await fs21.writeFile(filepath, JSON.stringify(exportData, null, 2));
+    await fs22.writeFile(filepath, JSON.stringify(exportData, null, 2));
     console.log(chalk15.green(`\u2705 Exported ${entries.length} log entries to: ${filepath}`));
   } catch (error) {
     console.error(chalk15.red(`\u274C Failed to export logs: ${error}`));
@@ -22529,7 +22920,7 @@ function createServicesCommand() {
   const servicesCmd = new Command("services").description("Manage juno-code service scripts").addHelpText("after", `
 Examples:
   $ juno-code services install            Install service scripts to ~/.juno_code/services/
-  $ juno-code services install --force    Reinstall/refresh service scripts (codex.py/claude.py)
+  $ juno-code services install --force    Reinstall/refresh service scripts (codex.py/claude.py/gemini.py)
   $ juno-code services list               List installed service scripts
   $ juno-code services status             Check installation status
   $ juno-code services uninstall          Remove all service scripts
@@ -22786,10 +23177,10 @@ autoload -U compinit && compinit`;
    */
   async isSourceCommandPresent(configPath, sourceCommand) {
     try {
-      if (!await fs2.pathExists(configPath)) {
+      if (!await fs3.pathExists(configPath)) {
         return false;
       }
-      const content = await fs2.readFile(configPath, "utf-8");
+      const content = await fs3.readFile(configPath, "utf-8");
       return content.includes("juno-code completion");
     } catch {
       return false;
@@ -22811,15 +23202,15 @@ autoload -U compinit && compinit`;
         continue;
       }
       try {
-        const completionExists = await fs2.pathExists(shell.completionPath);
-        const configExists = await fs2.pathExists(shell.configPath);
+        const completionExists = await fs3.pathExists(shell.completionPath);
+        const configExists = await fs3.pathExists(shell.configPath);
         const isSourced = configExists && await this.isSourceCommandPresent(
           shell.configPath,
           this.getSourceCommand(shell.name, shell.completionPath)
         );
         let lastInstalled;
         if (completionExists) {
-          const stats = await fs2.stat(shell.completionPath);
+          const stats = await fs3.stat(shell.completionPath);
           lastInstalled = stats.mtime;
         }
         statuses.push({
@@ -22845,7 +23236,7 @@ autoload -U compinit && compinit`;
   async ensureCompletionDirectory(shell) {
     const completionPath = this.getCompletionPath(shell);
     const completionDir = path3.dirname(completionPath);
-    await fs2.ensureDir(completionDir);
+    await fs3.ensureDir(completionDir);
   }
   /**
    * Ensure directory exists for shell configuration
@@ -22853,7 +23244,7 @@ autoload -U compinit && compinit`;
   async ensureConfigDirectory(shell) {
     const configPath = this.getConfigPath(shell);
     const configDir = path3.dirname(configPath);
-    await fs2.ensureDir(configDir);
+    await fs3.ensureDir(configDir);
   }
   /**
    * Get shell version information
@@ -22877,15 +23268,15 @@ autoload -U compinit && compinit`;
     try {
       const configPath = this.getConfigPath(shell);
       const configDir = path3.dirname(configPath);
-      await fs2.access(configDir, fs2.constants.W_OK);
+      await fs3.access(configDir, fs3.constants.W_OK);
     } catch {
       issues.push(`Cannot write to ${shell} configuration directory`);
     }
     try {
       const completionPath = this.getCompletionPath(shell);
       const completionDir = path3.dirname(completionPath);
-      await fs2.ensureDir(completionDir);
-      await fs2.access(completionDir, fs2.constants.W_OK);
+      await fs3.ensureDir(completionDir);
+      await fs3.access(completionDir, fs3.constants.W_OK);
     } catch {
       issues.push(`Cannot write to ${shell} completion directory`);
     }
@@ -22956,10 +23347,10 @@ var ContextAwareCompletion = class {
   async getSessionIds() {
     try {
       const sessionDir = path3.join(process.cwd(), ".juno_task", "sessions");
-      if (!await fs2.pathExists(sessionDir)) {
+      if (!await fs3.pathExists(sessionDir)) {
         return [];
       }
-      const sessions = await fs2.readdir(sessionDir);
+      const sessions = await fs3.readdir(sessionDir);
       return sessions.filter((name) => name.match(/^session_\d+$/)).map((name) => name.replace("session_", "")).sort((a, b) => parseInt(b) - parseInt(a));
     } catch {
       return [];
@@ -22973,8 +23364,8 @@ var ContextAwareCompletion = class {
       const builtinTemplates = ["basic", "advanced", "research", "development"];
       const customTemplatesDir = path3.join(process.cwd(), ".juno_task", "templates");
       let customTemplates = [];
-      if (await fs2.pathExists(customTemplatesDir)) {
-        const files = await fs2.readdir(customTemplatesDir);
+      if (await fs3.pathExists(customTemplatesDir)) {
+        const files = await fs3.readdir(customTemplatesDir);
         customTemplates = files.filter((name) => name.endsWith(".md") || name.endsWith(".hbs")).map((name) => path3.basename(name, path3.extname(name)));
       }
       return [...builtinTemplates, ...customTemplates].sort();
@@ -23051,7 +23442,7 @@ var CompletionInstaller = class {
       await this.shellDetector.ensureConfigDirectory(shell);
       const script = this.generateEnhancedCompletion(shell, "juno-code");
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      await fs2.writeFile(completionPath, script, "utf-8");
+      await fs3.writeFile(completionPath, script, "utf-8");
       const configPath = this.shellDetector.getConfigPath(shell);
       const sourceCommand = this.shellDetector.getSourceCommand(shell, completionPath);
       const warnings = [];
@@ -23059,7 +23450,7 @@ var CompletionInstaller = class {
         const isPresent = await this.shellDetector.isSourceCommandPresent(configPath, sourceCommand);
         if (!isPresent) {
           try {
-            await fs2.appendFile(configPath, `
+            await fs3.appendFile(configPath, `
 
 ${sourceCommand}
 `);
@@ -23090,8 +23481,8 @@ ${sourceCommand}
   async uninstall(shell) {
     try {
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      if (await fs2.pathExists(completionPath)) {
-        await fs2.remove(completionPath);
+      if (await fs3.pathExists(completionPath)) {
+        await fs3.remove(completionPath);
         return true;
       }
       return false;
@@ -23105,7 +23496,7 @@ ${sourceCommand}
   async isInstalled(shell) {
     try {
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      return await fs2.pathExists(completionPath);
+      return await fs3.pathExists(completionPath);
     } catch {
       return false;
     }
@@ -23906,11 +24297,11 @@ function setupMainCommand(program) {
       );
       const allOptions2 = { ...definedGlobalOptions, ...options };
       if (!globalOptions.subagent && !options.prompt && !options.interactive && !options.interactivePrompt) {
-        const fs21 = await import('fs-extra');
-        const path23 = await import('path');
+        const fs22 = await import('fs-extra');
+        const path24 = await import('path');
         const cwd2 = process.cwd();
-        const junoTaskDir = path23.join(cwd2, ".juno_task");
-        if (await fs21.pathExists(junoTaskDir)) {
+        const junoTaskDir = path24.join(cwd2, ".juno_task");
+        if (await fs22.pathExists(junoTaskDir)) {
           console.log(chalk15.blue.bold("\u{1F3AF} Juno Code - Auto-detected Initialized Project\n"));
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -23927,12 +24318,12 @@ function setupMainCommand(program) {
               allOptions2.subagent = config.defaultSubagent;
               console.log(chalk15.gray(`\u{1F916} Using configured subagent: ${chalk15.cyan(config.defaultSubagent)}`));
             }
-            const promptFile = path23.join(junoTaskDir, "prompt.md");
-            if (!allOptions2.prompt && await fs21.pathExists(promptFile)) {
+            const promptFile = path24.join(junoTaskDir, "prompt.md");
+            if (!allOptions2.prompt && await fs22.pathExists(promptFile)) {
               allOptions2.prompt = promptFile;
               console.log(chalk15.gray(`\u{1F4C4} Using default prompt: ${chalk15.cyan(".juno_task/prompt.md")}`));
             }
-            if (allOptions2.subagent && (allOptions2.prompt || await fs21.pathExists(promptFile))) {
+            if (allOptions2.subagent && (allOptions2.prompt || await fs22.pathExists(promptFile))) {
               console.log(chalk15.green("\u2713 Auto-detected project configuration\n"));
               const { mainCommandHandler: mainCommandHandler3 } = await Promise.resolve().then(() => (init_main(), main_exports));
               await mainCommandHandler3([], allOptions2, command);
@@ -24089,6 +24480,17 @@ async function main() {
       console.error("[DEBUG] Service auto-update failed:", error instanceof Error ? error.message : String(error));
     }
   }
+  try {
+    const { ScriptInstaller: ScriptInstaller2 } = await Promise.resolve().then(() => (init_script_installer(), script_installer_exports));
+    const updated = await ScriptInstaller2.autoUpdate(process.cwd(), true);
+    if (updated && (process.argv.includes("--verbose") || process.argv.includes("-v") || process.env.JUNO_CODE_DEBUG === "1")) {
+      console.error("[DEBUG] Project scripts auto-updated in .juno_task/scripts/");
+    }
+  } catch (error) {
+    if (process.env.JUNO_CODE_DEBUG === "1") {
+      console.error("[DEBUG] Script auto-update failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
   program.name("juno-code").description("TypeScript implementation of juno-code CLI tool for AI subagent orchestration").version(VERSION, "-V, --version", "Display version information").helpOption("-h, --help", "Display help information");
   setupGlobalOptions(program);
   const isVerbose = process.argv.includes("--verbose") || process.argv.includes("-v");
@@ -24096,10 +24498,10 @@ async function main() {
   const isHelpOrVersion = process.argv.includes("--help") || process.argv.includes("-h") || process.argv.includes("--version") || process.argv.includes("-V");
   const hasNoArguments = process.argv.length <= 2;
   const isInitCommand = process.argv.includes("init");
-  const fs21 = await import('fs-extra');
-  const path23 = await import('path');
-  const junoTaskDir = path23.join(process.cwd(), ".juno_task");
-  const isInitialized = await fs21.pathExists(junoTaskDir);
+  const fs22 = await import('fs-extra');
+  const path24 = await import('path');
+  const junoTaskDir = path24.join(process.cwd(), ".juno_task");
+  const isInitialized = await fs22.pathExists(junoTaskDir);
   if (!isHelpOrVersion && !hasNoArguments && !isInitCommand && isInitialized) {
     try {
       const { validateStartupConfigs: validateStartupConfigs2 } = await Promise.resolve().then(() => (init_startup_validation(), startup_validation_exports));