juno-code 1.0.32 → 1.0.34

package/dist/bin/cli.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import fs3 from 'fs-extra';
+import fs2 from 'fs-extra';
 import * as path3 from 'path';
 import path3__default, { dirname, join } from 'path';
-import * as os3 from 'os';
-import os3__default, { homedir, EOL } from 'os';
+import * as os4 from 'os';
+import os4__default, { homedir, EOL } from 'os';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import semver from 'semver';
@@ -315,12 +315,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 (fs3.existsSync(packageJsonPath)) {
+          if (fs2.existsSync(packageJsonPath)) {
             const packageJson2 = require3(packageJsonPath);
             return packageJson2.version;
           }
           packageJsonPath = path3.join(__dirname2, "..", "..", "..", "package.json");
-          if (fs3.existsSync(packageJsonPath)) {
+          if (fs2.existsSync(packageJsonPath)) {
             const packageJson2 = require3(packageJsonPath);
             return packageJson2.version;
           }
@@ -334,11 +334,11 @@ var init_service_installer = __esm({
        */
       static async getInstalledVersion() {
         try {
-          const exists = await fs3.pathExists(this.VERSION_FILE);
+          const exists = await fs2.pathExists(this.VERSION_FILE);
           if (!exists) {
             return null;
           }
-          const version3 = await fs3.readFile(this.VERSION_FILE, "utf-8");
+          const version3 = await fs2.readFile(this.VERSION_FILE, "utf-8");
           return version3.trim();
         } catch {
           return null;
@@ -349,7 +349,7 @@ var init_service_installer = __esm({
        */
       static async saveVersion() {
         const version3 = this.getPackageVersion();
-        await fs3.writeFile(this.VERSION_FILE, version3, "utf-8");
+        await fs2.writeFile(this.VERSION_FILE, version3, "utf-8");
       }
       /**
        * Check if services need to be updated based on version
@@ -361,7 +361,7 @@ var init_service_installer = __esm({
           if (!installedVersion) {
             return true;
           }
-          const exists = await fs3.pathExists(this.SERVICES_DIR);
+          const exists = await fs2.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return true;
           }
@@ -369,8 +369,10 @@ var init_service_installer = __esm({
             return true;
           }
           if (semver.eq(packageVersion, installedVersion)) {
-            const codexExists = await fs3.pathExists(path3.join(this.SERVICES_DIR, "codex.py"));
-            const claudeExists = await fs3.pathExists(path3.join(this.SERVICES_DIR, "claude.py"));
+            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) {
               return true;
             }
@@ -378,15 +380,32 @@ var init_service_installer = __esm({
               const packageServicesDir = this.getPackageServicesDir();
               const packageCodex = path3.join(packageServicesDir, "codex.py");
               const packageClaude = path3.join(packageServicesDir, "claude.py");
-              const packageCodexExists = await fs3.pathExists(packageCodex);
-              const packageClaudeExists = await fs3.pathExists(packageClaude);
-              if (packageCodexExists || packageClaudeExists) {
-                const isDevelopment2 = packageServicesDir.includes("/src/");
-                if (isDevelopment2) {
+              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;
                 }
               }
+              if (packageClaudeExists) {
+                const [pkg, inst] = await Promise.all([
+                  fs2.readFile(packageClaude, "utf-8"),
+                  fs2.readFile(installedClaude, "utf-8")
+                ]);
+                if (pkg !== inst) {
+                  return true;
+                }
+              }
+              const isDevelopment2 = packageServicesDir.includes("/src/");
+              if (isDevelopment2) {
+                return true;
+              }
             } catch {
+              return true;
             }
           }
           return false;
@@ -400,11 +419,11 @@ var init_service_installer = __esm({
       static getPackageServicesDir() {
         const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
         let servicesPath = path3.join(__dirname2, "..", "..", "templates", "services");
-        if (fs3.existsSync(servicesPath)) {
+        if (fs2.existsSync(servicesPath)) {
           return servicesPath;
         }
         servicesPath = path3.join(__dirname2, "..", "templates", "services");
-        if (fs3.existsSync(servicesPath)) {
+        if (fs2.existsSync(servicesPath)) {
           return servicesPath;
         }
         throw new Error("Could not find services directory in package");
@@ -415,18 +434,18 @@ var init_service_installer = __esm({
        */
       static async install(silent = false) {
         try {
-          await fs3.ensureDir(this.SERVICES_DIR);
+          await fs2.ensureDir(this.SERVICES_DIR);
           const packageServicesDir = this.getPackageServicesDir();
-          await fs3.copy(packageServicesDir, this.SERVICES_DIR, {
+          await fs2.copy(packageServicesDir, this.SERVICES_DIR, {
             overwrite: true,
             preserveTimestamps: true
           });
-          const files = await fs3.readdir(this.SERVICES_DIR);
+          const files = await fs2.readdir(this.SERVICES_DIR);
           for (const file of files) {
             const filePath = path3.join(this.SERVICES_DIR, file);
-            const stat = await fs3.stat(filePath);
+            const stat = await fs2.stat(filePath);
             if (stat.isFile() && (file.endsWith(".py") || file.endsWith(".sh"))) {
-              await fs3.chmod(filePath, 493);
+              await fs2.chmod(filePath, 493);
             }
           }
           await this.saveVersion();
@@ -473,11 +492,11 @@ var init_service_installer = __esm({
        */
       static async isInstalled() {
         try {
-          const exists = await fs3.pathExists(this.SERVICES_DIR);
+          const exists = await fs2.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return false;
           }
-          const files = await fs3.readdir(this.SERVICES_DIR);
+          const files = await fs2.readdir(this.SERVICES_DIR);
           return files.length > 0;
         } catch {
           return false;
@@ -500,11 +519,11 @@ var init_service_installer = __esm({
        */
       static async listServices() {
         try {
-          const exists = await fs3.pathExists(this.SERVICES_DIR);
+          const exists = await fs2.pathExists(this.SERVICES_DIR);
           if (!exists) {
             return [];
           }
-          const files = await fs3.readdir(this.SERVICES_DIR);
+          const files = await fs2.readdir(this.SERVICES_DIR);
           return files.filter((file) => file.endsWith(".py") || file.endsWith(".sh"));
         } catch {
           return [];
@@ -515,9 +534,9 @@ var init_service_installer = __esm({
        */
       static async uninstall() {
         try {
-          const exists = await fs3.pathExists(this.SERVICES_DIR);
+          const exists = await fs2.pathExists(this.SERVICES_DIR);
           if (exists) {
-            await fs3.remove(this.SERVICES_DIR);
+            await fs2.remove(this.SERVICES_DIR);
             console.log("\u2713 Services uninstalled");
           }
         } catch (error) {
@@ -1093,17 +1112,17 @@ async function ensureHooksConfig(baseDir) {
   try {
     const configDir = path3.join(baseDir, ".juno_task");
     const configPath = path3.join(configDir, "config.json");
-    await fs3.ensureDir(configDir);
-    const configExists = await fs3.pathExists(configPath);
+    await fs2.ensureDir(configDir);
+    const configExists = await fs2.pathExists(configPath);
     const allHookTypes = getDefaultHooks();
     if (!configExists) {
       const defaultConfig = {
         ...DEFAULT_CONFIG,
         hooks: allHookTypes
       };
-      await fs3.writeJson(configPath, defaultConfig, { spaces: 2 });
+      await fs2.writeJson(configPath, defaultConfig, { spaces: 2 });
     } else {
-      const existingConfig = await fs3.readJson(configPath);
+      const existingConfig = await fs2.readJson(configPath);
       let needsUpdate = false;
       if (!existingConfig.hooks) {
         existingConfig.hooks = allHookTypes;
@@ -1121,7 +1140,7 @@ async function ensureHooksConfig(baseDir) {
         needsUpdate = true;
       }
       if (needsUpdate) {
-        await fs3.writeJson(configPath, existingConfig, { spaces: 2 });
+        await fs2.writeJson(configPath, existingConfig, { spaces: 2 });
       }
     }
   } catch (error) {
@@ -3276,13 +3295,9 @@ var init_advanced_logger = __esm({
       /**
        * Output formatted log
        */
-      output(formatted, level) {
+      output(formatted, _level) {
         if (this.options.output === "console" || this.options.output === "both") {
-          if (level >= 3 /* WARN */) {
-            console.error(formatted);
-          } else {
-            console.log(formatted);
-          }
+          console.error(formatted);
         }
         if (this.options.output === "file" || this.options.output === "both") {
           this.writeToFile(formatted);
@@ -4839,7 +4854,7 @@ var init_config2 = __esm({
           return cached;
         }
         try {
-          const configContent = await fs3.readFile(configPath, "utf-8");
+          const configContent = await fs2.readFile(configPath, "utf-8");
           const config = JSON.parse(configContent);
           this.validateConfig(config);
           const resolvedConfig = this.resolveConfigPaths(config, path3.dirname(configPath));
@@ -4861,7 +4876,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 fs3.pathExists(configPath)) {
+          if (await fs2.pathExists(configPath)) {
             return configPath;
           }
           currentDir = path3.dirname(currentDir);
@@ -5047,7 +5062,7 @@ var init_logger = __esm({
        * Matches Python's generate_log_file function
        */
       async initialize(subagent = "mcp") {
-        await fs3.ensureDir(this.logDirectory);
+        await fs2.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);
@@ -5056,7 +5071,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 fs3.writeFile(this.logFilePath, header);
+        await fs2.writeFile(this.logFilePath, header);
       }
       /**
        * Format log message matching Python version format
@@ -5074,7 +5089,7 @@ var init_logger = __esm({
         if (!this.logFilePath) {
           throw new Error("Logger not initialized. Call initialize() first.");
         }
-        await fs3.appendFile(this.logFilePath, message);
+        await fs2.appendFile(this.logFilePath, message);
       }
       /**
        * Log message at specified level
@@ -5978,7 +5993,7 @@ var init_client = __esm({
             `${serverName}`,
             // Assume it's in PATH
             `/usr/local/bin/${serverName}`,
-            path3__default.resolve(os3__default.homedir(), `.local/bin/${serverName}`),
+            path3__default.resolve(os4__default.homedir(), `.local/bin/${serverName}`),
             path3__default.resolve(this.options.workingDirectory || process.cwd(), `${serverName}`)
           ];
           for (const serverPath of possiblePaths) {
@@ -6987,7 +7002,7 @@ var init_shell_backend = __esm({
         });
         try {
           const scriptPath = await this.findScriptForSubagent(subagentType);
-          const result = await this.executeScript(scriptPath, request, toolId);
+          const result = await this.executeScript(scriptPath, request, toolId, subagentType);
           const duration = Date.now() - startTime;
           await this.emitProgressEvent({
             sessionId: request.metadata?.sessionId || "unknown",
@@ -7004,8 +7019,9 @@ var init_shell_backend = __esm({
               phase: "completion"
             }
           });
+          const structuredResult = this.buildStructuredOutput(subagentType, result);
           return {
-            content: result.output,
+            content: structuredResult.content,
             status: result.success ? "completed" : "failed",
             startTime: new Date(startTime),
             endTime: /* @__PURE__ */ new Date(),
@@ -7013,6 +7029,7 @@ var init_shell_backend = __esm({
             error: result.error ? { type: "shell_execution", message: result.error, timestamp: /* @__PURE__ */ new Date() } : void 0,
             progressEvents: [],
             // Progress events are handled via callbacks
+            ...structuredResult.metadata ? { metadata: structuredResult.metadata } : void 0,
             request
           };
         } catch (error) {
@@ -7083,7 +7100,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 fs3.ensureDir(logDir);
+          await fs2.ensureDir(logDir);
         } catch (error) {
           if (this.config?.debug) {
             engineLogger.warn(`Failed to create log directory: ${error instanceof Error ? error.message : String(error)}`);
@@ -7108,7 +7125,7 @@ var init_shell_backend = __esm({
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
           const logEntry = `[${timestamp}] ${message}
 `;
-          await fs3.appendFile(this.logFilePath, logEntry, "utf-8");
+          await fs2.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)}`);
@@ -7178,8 +7195,8 @@ var init_shell_backend = __esm({
       /**
        * Execute a shell script
        */
-      async executeScript(scriptPath, request, toolId) {
-        return new Promise((resolve9, reject) => {
+      async executeScript(scriptPath, request, toolId, subagentType) {
+        return new Promise(async (resolve9, reject) => {
           const startTime = Date.now();
           const isPython = scriptPath.endsWith(".py");
           const env2 = {
@@ -7192,6 +7209,19 @@ var init_shell_backend = __esm({
             JUNO_ITERATION: String(request.arguments?.iteration || 1),
             JUNO_TOOL_ID: toolId
           };
+          let captureDir = null;
+          let capturePath = null;
+          if (subagentType === "claude") {
+            try {
+              captureDir = await promises.mkdtemp(path3.join(os4__default.tmpdir(), "juno-shell-"));
+              capturePath = path3.join(captureDir, `subagent_${toolId}.json`);
+              env2.JUNO_SUBAGENT_CAPTURE_PATH = capturePath;
+            } catch (error) {
+              if (this.config?.debug) {
+                engineLogger.warn(`Failed to prepare subagent capture path: ${error instanceof Error ? error.message : String(error)}`);
+              }
+            }
+          }
           const command = isPython ? "python3" : "bash";
           const args = [scriptPath];
           if (isPython && request.arguments?.instruction) {
@@ -7266,20 +7296,46 @@ var init_shell_backend = __esm({
             }
           });
           child.on("close", (exitCode) => {
-            if (isProcessKilled) return;
-            const duration = Date.now() - startTime;
-            const success = exitCode === 0;
-            if (this.config.debug) {
-              engineLogger.debug(`Script execution completed with exit code: ${exitCode}, duration: ${duration}ms`);
-              engineLogger.debug(`Stdout length: ${stdout2.length}, Stderr length: ${stderr.length}`);
-            }
-            resolve9({
-              success,
-              output: stdout2,
-              error: stderr || void 0,
-              exitCode: exitCode || 0,
-              duration
-            });
+            void (async () => {
+              if (isProcessKilled) return;
+              const duration = Date.now() - startTime;
+              const success = exitCode === 0;
+              let subAgentResponse;
+              if (capturePath) {
+                try {
+                  const captured = await promises.readFile(capturePath, "utf-8");
+                  if (captured.trim()) {
+                    subAgentResponse = JSON.parse(captured);
+                  }
+                } catch (error) {
+                  if (this.config?.debug) {
+                    engineLogger.warn(`Failed to read subagent capture: ${error instanceof Error ? error.message : String(error)}`);
+                  }
+                } finally {
+                  if (captureDir) {
+                    try {
+                      await promises.rm(captureDir, { recursive: true, force: true });
+                    } catch (cleanupError) {
+                      if (this.config?.debug) {
+                        engineLogger.warn(`Failed to clean capture directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+                      }
+                    }
+                  }
+                }
+              }
+              if (this.config.debug) {
+                engineLogger.debug(`Script execution completed with exit code: ${exitCode}, duration: ${duration}ms`);
+                engineLogger.debug(`Stdout length: ${stdout2.length}, Stderr length: ${stderr.length}`);
+              }
+              resolve9({
+                success,
+                output: stdout2,
+                error: stderr || void 0,
+                exitCode: exitCode || 0,
+                duration,
+                ...subAgentResponse ? { subAgentResponse } : void 0
+              });
+            })();
           });
           child.on("error", (error) => {
             if (isProcessKilled) return;
@@ -7311,6 +7367,66 @@ var init_shell_backend = __esm({
           });
         });
       }
+      /**
+       * Build a structured, JSON-parsable result payload for programmatic capture while
+       * preserving the shell backend's existing on-screen streaming behavior.
+       */
+      buildStructuredOutput(subagentType, result) {
+        if (subagentType === "claude") {
+          const claudeEvent = result.subAgentResponse ?? this.extractLastJsonEvent(result.output);
+          const isError = claudeEvent?.is_error ?? claudeEvent?.subtype === "error" ?? !result.success;
+          const structuredPayload = {
+            type: "result",
+            subtype: claudeEvent?.subtype || (isError ? "error" : "success"),
+            is_error: isError,
+            result: claudeEvent?.result ?? claudeEvent?.error ?? claudeEvent?.content ?? result.output,
+            error: claudeEvent?.error,
+            stderr: result.error,
+            datetime: claudeEvent?.datetime,
+            counter: claudeEvent?.counter,
+            session_id: claudeEvent?.session_id,
+            num_turns: claudeEvent?.num_turns,
+            duration_ms: claudeEvent?.duration_ms ?? result.duration,
+            exit_code: result.exitCode,
+            total_cost_usd: claudeEvent?.total_cost_usd,
+            usage: claudeEvent?.usage,
+            modelUsage: claudeEvent?.modelUsage || claudeEvent?.model_usage || {},
+            permission_denials: claudeEvent?.permission_denials || [],
+            uuid: claudeEvent?.uuid,
+            sub_agent_response: claudeEvent
+          };
+          const metadata = {
+            ...claudeEvent ? { subAgentResponse: claudeEvent } : void 0,
+            structuredOutput: true,
+            contentType: "application/json",
+            rawOutput: result.output
+          };
+          return {
+            content: JSON.stringify(structuredPayload),
+            metadata
+          };
+        }
+        return { content: result.output, metadata: result.metadata };
+      }
+      /**
+       * Extract the last valid JSON object from a script's stdout to use as a structured payload fallback.
+       */
+      extractLastJsonEvent(output) {
+        if (!output) {
+          return null;
+        }
+        const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try {
+            const parsed = JSON.parse(lines[i]);
+            if (parsed && typeof parsed === "object") {
+              return parsed;
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
       /**
        * Parse streaming events from script output
        * Handles both JSON format (Claude) and TEXT format (Codex)
@@ -12807,7 +12923,7 @@ var init_main = __esm({
             return await this.collectInteractivePrompt();
           } else {
             const defaultPromptPath = path3.join(process.cwd(), ".juno_task", "prompt.md");
-            if (await fs3.pathExists(defaultPromptPath)) {
+            if (await fs2.pathExists(defaultPromptPath)) {
               console.error(chalk15.blue(`\u{1F4C4} Using default prompt: ${chalk15.cyan(".juno_task/prompt.md")}`));
               return await this.loadPromptFromFile(defaultPromptPath);
             } else {
@@ -12835,7 +12951,7 @@ var init_main = __esm({
         }
         try {
           const resolvedPath = path3.resolve(prompt);
-          return await fs3.pathExists(resolvedPath);
+          return await fs2.pathExists(resolvedPath);
         } catch {
           return false;
         }
@@ -12843,7 +12959,7 @@ var init_main = __esm({
       async loadPromptFromFile(filePath) {
         try {
           const resolvedPath = path3.resolve(filePath);
-          const content = await fs3.readFile(resolvedPath, "utf-8");
+          const content = await fs2.readFile(resolvedPath, "utf-8");
           if (!content.trim()) {
             throw new FileSystemError(
               "Prompt file is empty",
@@ -13050,7 +13166,11 @@ var init_main = __esm({
 \u274C Execution failed (${elapsed})`));
         }
         const lastIteration = result.iterations[result.iterations.length - 1];
-        if (lastIteration && lastIteration.toolResult.content && !this.hasStreamedJsonOutput) {
+        const structuredOutput = lastIteration?.toolResult.metadata?.structuredOutput === true;
+        const shouldPrintResult = Boolean(
+          lastIteration && lastIteration.toolResult.content && (!this.hasStreamedJsonOutput || structuredOutput)
+        );
+        if (shouldPrintResult) {
           console.error(chalk15.blue("\n\u{1F4C4} Result:"));
           console.log(lastIteration.toolResult.content);
         }
@@ -13251,7 +13371,7 @@ async function validateJSONFile(configSchema, baseDir) {
   const warnings = [];
   const filePath = path3__default.join(baseDir, configSchema.file);
   try {
-    const exists = await fs3.pathExists(filePath);
+    const exists = await fs2.pathExists(filePath);
     if (!exists) {
       if (configSchema.required) {
         errors.push({
@@ -13274,7 +13394,7 @@ async function validateJSONFile(configSchema, baseDir) {
       return { isValid: !configSchema.required, errors, warnings };
     }
     try {
-      await fs3.access(filePath, fs3.constants.R_OK);
+      await fs2.access(filePath, fs2.constants.R_OK);
     } catch (accessError) {
       errors.push({
         file: configSchema.file,
@@ -13290,7 +13410,7 @@ async function validateJSONFile(configSchema, baseDir) {
     }
     let jsonData;
     try {
-      const fileContent = await fs3.readFile(filePath, "utf8");
+      const fileContent = await fs2.readFile(filePath, "utf8");
       jsonData = JSON.parse(fileContent);
     } catch (parseError) {
       const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
@@ -13388,7 +13508,7 @@ async function validateJSONConfigs(baseDir = process.cwd(), backendType = "mcp")
 }
 function displayValidationResults(result) {
   if (result.isValid && result.warnings.length === 0) {
-    console.log(chalk15.green("\u2705 All configuration files are valid\n"));
+    console.error(chalk15.green("\u2705 All configuration files are valid\n"));
     return;
   }
   if (result.errors.length > 0) {
@@ -13425,7 +13545,7 @@ function displayValidationResults(result) {
 }
 async function logValidationResults(result, baseDir = process.cwd()) {
   const logDir = path3__default.join(baseDir, ".juno_task", "logs");
-  await fs3.ensureDir(logDir);
+  await fs2.ensureDir(logDir);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const logFile = path3__default.join(logDir, `startup-validation-${timestamp}.log`);
   const logContent = [
@@ -13468,7 +13588,7 @@ async function logValidationResults(result, baseDir = process.cwd()) {
       logContent.push(``);
     }
   }
-  await fs3.writeFile(logFile, logContent.join("\n"));
+  await fs2.writeFile(logFile, logContent.join("\n"));
   return logFile;
 }
 async function validateStartupConfigs(baseDir = process.cwd(), verbose = false) {
@@ -13802,7 +13922,7 @@ var TemplateEngine = class {
     let overallError;
     try {
       if (!options.dryRun) {
-        await fs3.ensureDir(targetDirectory);
+        await fs2.ensureDir(targetDirectory);
       }
       for (const template of templates) {
         try {
@@ -15152,7 +15272,7 @@ This directory contains specification documents for your project.
     const fileName = this.getTemplateFileName(template);
     const targetPath = path3.join(targetDirectory, fileName);
     try {
-      const fileExists = await fs3.pathExists(targetPath);
+      const fileExists = await fs2.pathExists(targetPath);
       if (fileExists && !options.force && options.onConflict !== "overwrite") {
         return {
           path: targetPath,
@@ -15174,10 +15294,10 @@ This directory contains specification documents for your project.
       }
       if (options.createBackup && fileExists) {
         const backupPath = `${targetPath}.backup.${Date.now()}`;
-        await fs3.copy(targetPath, backupPath);
+        await fs2.copy(targetPath, backupPath);
       }
-      await fs3.ensureDir(path3.dirname(targetPath));
-      await fs3.writeFile(targetPath, renderedContent, "utf8");
+      await fs2.ensureDir(path3.dirname(targetPath));
+      await fs2.writeFile(targetPath, renderedContent, "utf8");
       return {
         path: targetPath,
         content: renderedContent,
@@ -15441,7 +15561,7 @@ var SimpleInitTUI = class {
   }
   async confirmSave(targetDirectory) {
     const junoTaskPath = path3.join(targetDirectory, ".juno_task");
-    if (await fs3.pathExists(junoTaskPath)) {
+    if (await fs2.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"));
@@ -15486,16 +15606,16 @@ var SimpleProjectGenerator = class {
   async generate() {
     const { targetDirectory, variables, force } = this.context;
     console.log(chalk15.blue("\u{1F4C1} Creating project directory..."));
-    await fs3.ensureDir(targetDirectory);
+    await fs2.ensureDir(targetDirectory);
     const junoTaskDir = path3.join(targetDirectory, ".juno_task");
-    const junoTaskExists = await fs3.pathExists(junoTaskDir);
+    const junoTaskExists = await fs2.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 fs3.ensureDir(junoTaskDir);
+    await fs2.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..."));
@@ -15529,21 +15649,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 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);
+    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);
     const userFeedbackTemplate = templateEngine.getBuiltInTemplate("USER_FEEDBACK.md");
     if (userFeedbackTemplate) {
       const userFeedbackContent = await templateEngine.render(userFeedbackTemplate, templateContext);
-      await fs3.writeFile(path3.join(junoTaskDir, "USER_FEEDBACK.md"), userFeedbackContent);
+      await fs2.writeFile(path3.join(junoTaskDir, "USER_FEEDBACK.md"), userFeedbackContent);
     }
     const planTemplate = templateEngine.getBuiltInTemplate("plan.md");
     if (planTemplate) {
       const planContent = await templateEngine.render(planTemplate, templateContext);
-      await fs3.writeFile(path3.join(junoTaskDir, "plan.md"), planContent);
+      await fs2.writeFile(path3.join(junoTaskDir, "plan.md"), planContent);
     }
     const specsDir = path3.join(junoTaskDir, "specs");
-    await fs3.ensureDir(specsDir);
+    await fs2.ensureDir(specsDir);
     const specsReadmeContent = `# Project Specifications
 
 This directory contains detailed specifications for the project components.
@@ -15560,7 +15680,7 @@ This directory contains detailed specifications for the project components.
 - Avoid conflicts with existing file names
 - Use \`.md\` extension for all specification files
 `;
-    await fs3.writeFile(path3.join(specsDir, "README.md"), specsReadmeContent);
+    await fs2.writeFile(path3.join(specsDir, "README.md"), specsReadmeContent);
     const requirementsContent = `# Requirements Specification
 
 ## Functional Requirements
@@ -15607,7 +15727,7 @@ This directory contains detailed specifications for the project components.
 - Code quality: Clean, maintainable codebase
 - Documentation: Complete and accurate documentation
 `;
-    await fs3.writeFile(path3.join(specsDir, "requirements.md"), requirementsContent);
+    await fs2.writeFile(path3.join(specsDir, "requirements.md"), requirementsContent);
     const architectureContent = `# Architecture Specification
 
 ## System Overview
@@ -15689,7 +15809,7 @@ This project uses AI-assisted development with juno-code to achieve: ${variables
 - Performance monitoring
 - Security best practices
 `;
-    await fs3.writeFile(path3.join(specsDir, "architecture.md"), architectureContent);
+    await fs2.writeFile(path3.join(specsDir, "architecture.md"), architectureContent);
     const claudeContent = `# Claude Development Session Learnings
 
 ## Project Overview
@@ -15761,7 +15881,7 @@ This file will be updated as development progresses to track:
 - Solutions to complex problems
 - Performance improvements and optimizations
 `;
-    await fs3.writeFile(path3.join(targetDirectory, "CLAUDE.md"), claudeContent);
+    await fs2.writeFile(path3.join(targetDirectory, "CLAUDE.md"), claudeContent);
     const agentsContent = `# AI Agent Selection and Performance
 
 ## Available Agents
@@ -15825,7 +15945,7 @@ Track agent performance for:
 4. **Feedback Loop**: Provide feedback to improve agent performance
 5. **Performance Monitoring**: Track and optimize agent usage
 `;
-    await fs3.writeFile(path3.join(targetDirectory, "AGENTS.md"), agentsContent);
+    await fs2.writeFile(path3.join(targetDirectory, "AGENTS.md"), agentsContent);
     const readmeContent = `# ${variables.PROJECT_NAME}
 
 ${variables.DESCRIPTION}
@@ -15922,7 +16042,7 @@ ${variables.GIT_URL}` : ""}
 Created with juno-code on ${variables.CURRENT_DATE}
 ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
 `;
-    await fs3.writeFile(path3.join(targetDirectory, "README.md"), readmeContent);
+    await fs2.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..."));
@@ -15974,7 +16094,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       hooks: getDefaultHooks()
     };
     const configPath = path3.join(junoTaskDir, "config.json");
-    await fs3.writeFile(configPath, JSON.stringify(configContent, null, 2));
+    await fs2.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) {
@@ -16028,7 +16148,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       }
     };
     const mcpPath = path3.join(junoTaskDir, "mcp.json");
-    await fs3.writeFile(mcpPath, JSON.stringify(mcpContent, null, 2));
+    await fs2.writeFile(mcpPath, JSON.stringify(mcpContent, null, 2));
     console.log(chalk15.green(`   \u2713 Created .juno_task/mcp.json with roundtable-ai server configuration`));
   }
   getDefaultModelForSubagent(subagent) {
@@ -16047,7 +16167,7 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
   async copyScriptsFromTemplates(junoTaskDir) {
     try {
       const scriptsDir = path3.join(junoTaskDir, "scripts");
-      await fs3.ensureDir(scriptsDir);
+      await fs2.ensureDir(scriptsDir);
       const __filename2 = fileURLToPath(import.meta.url);
       const __dirname2 = path3.dirname(__filename2);
       let templatesScriptsDir;
@@ -16058,11 +16178,11 @@ ${variables.EDITOR ? `using ${variables.EDITOR} as primary AI subagent` : ""}
       } else {
         templatesScriptsDir = path3.join(__dirname2, "../../templates/scripts");
       }
-      if (!await fs3.pathExists(templatesScriptsDir)) {
+      if (!await fs2.pathExists(templatesScriptsDir)) {
         console.log(chalk15.yellow("   \u26A0\uFE0F  Template scripts directory not found, skipping script installation"));
         return;
       }
-      const scriptFiles = await fs3.readdir(templatesScriptsDir);
+      const scriptFiles = await fs2.readdir(templatesScriptsDir);
       if (scriptFiles.length === 0) {
         console.log(chalk15.gray("   \u2139\uFE0F  No template scripts found to install"));
         return;
@@ -16071,11 +16191,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 fs3.stat(sourcePath);
+        const stats = await fs2.stat(sourcePath);
         if (stats.isFile()) {
-          await fs3.copy(sourcePath, destPath);
+          await fs2.copy(sourcePath, destPath);
           if (scriptFile.endsWith(".sh")) {
-            await fs3.chmod(destPath, 493);
+            await fs2.chmod(destPath, 493);
           }
           copiedCount++;
           console.log(chalk15.green(`   \u2713 Installed script: ${scriptFile}`));
@@ -16098,7 +16218,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 fs3.pathExists(installScript)) {
+      if (!await fs2.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;
@@ -16395,20 +16515,20 @@ init_types();
 async function loadInitPrompt(directory) {
   const junoTaskDir = path3.join(directory, ".juno_task");
   const initFile = path3.join(junoTaskDir, "init.md");
-  if (!await fs3.pathExists(junoTaskDir)) {
+  if (!await fs2.pathExists(junoTaskDir)) {
     throw new FileSystemError(
       'No .juno_task directory found. Run "juno-code init" first.',
       junoTaskDir
     );
   }
-  if (!await fs3.pathExists(initFile)) {
+  if (!await fs2.pathExists(initFile)) {
     throw new FileSystemError(
       "No init.md file found in .juno_task directory",
       initFile
     );
   }
   try {
-    const content = await fs3.readFile(initFile, "utf-8");
+    const content = await fs2.readFile(initFile, "utf-8");
     if (!content.trim()) {
       throw new FileSystemError(
         "init.md file is empty. Please add task instructions.",
@@ -17440,8 +17560,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 fs3.ensureDir(path3.dirname(testFilePath));
-      await fs3.writeFile(testFilePath, testContent);
+      await fs2.ensureDir(path3.dirname(testFilePath));
+      await fs2.writeFile(testFilePath, testContent);
       testFiles.push(testFilePath);
     }
     return testFiles;
@@ -17693,8 +17813,8 @@ var TestExecutionEngine = class {
   async collectCoverage(request) {
     const coverageFile = path3.join(request.workingDirectory, "coverage", "coverage-summary.json");
     try {
-      if (await fs3.pathExists(coverageFile)) {
-        const coverageData = await fs3.readJson(coverageFile);
+      if (await fs2.pathExists(coverageFile)) {
+        const coverageData = await fs2.readJson(coverageFile);
         return {
           lines: coverageData.total?.lines?.pct || 0,
           functions: coverageData.total?.functions?.pct || 0,
@@ -17877,8 +17997,8 @@ var TestReportEngine = class {
       suggestions: analysis.suggestions,
       recommendations: analysis.recommendations
     };
-    await fs3.ensureDir(path3.dirname(outputPath));
-    await fs3.writeJson(outputPath, report, { spaces: 2 });
+    await fs2.ensureDir(path3.dirname(outputPath));
+    await fs2.writeJson(outputPath, report, { spaces: 2 });
     return outputPath;
   }
   async generateHTMLReport(analysis, outputPath, includeVisualizations) {
@@ -17941,8 +18061,8 @@ var TestReportEngine = class {
 </body>
 </html>
     `.trim();
-    await fs3.ensureDir(path3.dirname(outputPath));
-    await fs3.writeFile(outputPath, html);
+    await fs2.ensureDir(path3.dirname(outputPath));
+    await fs2.writeFile(outputPath, html);
     return outputPath;
   }
   generateCharts(analysis) {
@@ -17999,8 +18119,8 @@ ${analysis.suggestions.map((suggestion) => `- ${suggestion}`).join("\n")}
 
 ${analysis.recommendations.map((rec) => `- ${rec}`).join("\n")}
     `.trim();
-    await fs3.ensureDir(path3.dirname(outputPath));
-    await fs3.writeFile(outputPath, markdown);
+    await fs2.ensureDir(path3.dirname(outputPath));
+    await fs2.writeFile(outputPath, markdown);
     return outputPath;
   }
   async displayConsoleReport(analysis) {
@@ -18340,7 +18460,7 @@ async function compactConfigFile(filePath, options = {}) {
     preserveDays = 30,
     preservePatterns = []
   } = options;
-  const originalContent = await fs3.readFile(filePath, "utf-8");
+  const originalContent = await fs2.readFile(filePath, "utf-8");
   const originalSize = originalContent.length;
   let backupPath = "";
   if (createBackup && !dryRun) {
@@ -18349,7 +18469,7 @@ async function compactConfigFile(filePath, options = {}) {
     const basename11 = path3.basename(filePath, ext);
     const dirname12 = path3.dirname(filePath);
     backupPath = path3.join(dirname12, `${basename11}.backup.${timestamp}${ext}`);
-    await fs3.writeFile(backupPath, originalContent, "utf-8");
+    await fs2.writeFile(backupPath, originalContent, "utf-8");
   }
   const compactionAnalysis = analyzeMarkdownStructure(originalContent);
   const compactedContent = compactMarkdownContent(
@@ -18364,7 +18484,7 @@ async function compactConfigFile(filePath, options = {}) {
   const compactedSize = finalContent.length;
   const reductionPercentage = Math.round((originalSize - compactedSize) / originalSize * 100);
   if (!dryRun) {
-    await fs3.writeFile(filePath, finalContent, "utf-8");
+    await fs2.writeFile(filePath, finalContent, "utf-8");
   }
   return {
     originalSize,
@@ -18494,7 +18614,7 @@ function formatFileSize(bytes) {
 }
 async function shouldCompactFile(filePath, sizeThresholdKB = 50, ageThresholdDays = 30) {
   try {
-    const stats = await fs3.stat(filePath);
+    const stats = await fs2.stat(filePath);
     const sizeKB = stats.size / 1024;
     if (sizeKB > sizeThresholdKB) {
       return true;
@@ -18516,19 +18636,19 @@ async function archiveResolvedIssues(options) {
     feedbackFile,
     archiveDir = path3.join(path3.dirname(feedbackFile), "archives"),
     openIssuesThreshold = 10} = options;
-  if (!await fs3.pathExists(feedbackFile)) {
+  if (!await fs2.pathExists(feedbackFile)) {
     throw new Error(`Feedback file does not exist: ${feedbackFile}`);
   }
-  const content = await fs3.readFile(feedbackFile, "utf-8");
+  const content = await fs2.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 fs3.ensureDir(path3.dirname(logFile));
+    await fs2.ensureDir(path3.dirname(logFile));
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    await fs3.appendFile(logFile, `[${timestamp}] ${warning}
+    await fs2.appendFile(logFile, `[${timestamp}] ${warning}
 `);
   }
   if (parsed.resolvedIssues.length === 0) {
@@ -18545,10 +18665,10 @@ async function archiveResolvedIssues(options) {
   const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
   const archiveFile = path3.join(archiveDir, `USER_FEEDBACK_archive_${currentYear}.md`);
   {
-    await fs3.ensureDir(archiveDir);
+    await fs2.ensureDir(archiveDir);
     await appendToArchive(archiveFile, parsed.resolvedIssues);
     const compactedContent = generateCompactedFeedback(parsed.openIssues, parsed.metadata);
-    await fs3.writeFile(feedbackFile, compactedContent, "utf-8");
+    await fs2.writeFile(feedbackFile, compactedContent, "utf-8");
   }
   {
     console.log(chalk15.green(`\u2705 Archived ${parsed.resolvedIssues.length} resolved issues`));
@@ -18595,8 +18715,8 @@ function parseUserFeedback(content) {
 async function appendToArchive(archiveFile, resolvedIssues) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let archiveContent = "";
-  if (await fs3.pathExists(archiveFile)) {
-    archiveContent = await fs3.readFile(archiveFile, "utf-8");
+  if (await fs2.pathExists(archiveFile)) {
+    archiveContent = await fs2.readFile(archiveFile, "utf-8");
   } else {
     const year = path3.basename(archiveFile).match(/(\d{4})/)?.[1] || (/* @__PURE__ */ new Date()).getFullYear();
     archiveContent = `# User Feedback Archive ${year}
@@ -18630,7 +18750,7 @@ ${resolvedIssue}
       `- Last updated: ${timestamp}`
     );
   }
-  await fs3.writeFile(archiveFile, archiveContent, "utf-8");
+  await fs2.writeFile(archiveFile, archiveContent, "utf-8");
 }
 function generateCompactedFeedback(openIssues, metadata) {
   let content = metadata.trim() + "\n";
@@ -18655,15 +18775,15 @@ async function shouldArchive(feedbackFile, options = {}) {
     // 50KB
     lineCountThreshold = 500
   } = options;
-  if (!await fs3.pathExists(feedbackFile)) {
+  if (!await fs2.pathExists(feedbackFile)) {
     return {
       shouldArchive: false,
       reasons: [],
       stats: { openIssuesCount: 0, resolvedIssuesCount: 0, fileSizeBytes: 0, lineCount: 0 }
     };
   }
-  const content = await fs3.readFile(feedbackFile, "utf-8");
-  const stats = await fs3.stat(feedbackFile);
+  const content = await fs2.readFile(feedbackFile, "utf-8");
+  const stats = await fs2.stat(feedbackFile);
   const parsed = parseUserFeedback(content);
   const lineCount = content.split("\n").length;
   const reasons = [];
@@ -18737,16 +18857,16 @@ var EnhancedFeedbackFileManager = class {
     this.feedbackFile = feedbackFile;
   }
   async ensureExists() {
-    if (!await fs3.pathExists(this.feedbackFile)) {
+    if (!await fs2.pathExists(this.feedbackFile)) {
       await this.createInitialFile();
     }
   }
   async addFeedback(issue, testCriteria) {
     await this.ensureExists();
     try {
-      const content = await fs3.readFile(this.feedbackFile, "utf-8");
+      const content = await fs2.readFile(this.feedbackFile, "utf-8");
       const updatedContent = this.addIssueToContent(content, issue, testCriteria);
-      await fs3.writeFile(this.feedbackFile, updatedContent, "utf-8");
+      await fs2.writeFile(this.feedbackFile, updatedContent, "utf-8");
     } catch (error) {
       throw new ValidationError(
         `Failed to save feedback: ${error}`,
@@ -18759,12 +18879,12 @@ var EnhancedFeedbackFileManager = class {
    */
   async repairMalformedFile() {
     try {
-      const content = await fs3.readFile(this.feedbackFile, "utf-8");
+      const content = await fs2.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 fs3.writeFile(backupPath, content, "utf-8");
+        await fs2.writeFile(backupPath, content, "utf-8");
         const existingIssues = this.extractIssuesFromMalformedContent(content);
         await this.createInitialFile(existingIssues);
       }
@@ -18796,8 +18916,8 @@ List any features you'd like to see added or bugs you've encountered.
 
 <!-- Resolved issues will be moved here -->
 `;
-    await fs3.ensureDir(path3.dirname(this.feedbackFile));
-    await fs3.writeFile(this.feedbackFile, initialContent, "utf-8");
+    await fs2.ensureDir(path3.dirname(this.feedbackFile));
+    await fs2.writeFile(this.feedbackFile, initialContent, "utf-8");
   }
   addIssueToContent(content, issue, testCriteria) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -18913,17 +19033,17 @@ async function handleCompactCommand(subArgs, options) {
     if (subArgs.length > 0) {
       for (const filePath of subArgs) {
         const resolvedPath = path3.resolve(filePath);
-        if (await fs3.pathExists(resolvedPath)) {
+        if (await fs2.pathExists(resolvedPath)) {
           filesToCompact.push(resolvedPath);
         } else {
           console.warn(chalk15.yellow(`\u26A0\uFE0F  File not found: ${filePath}`));
         }
       }
     } else {
-      if (await fs3.pathExists(defaultClaudeFile)) {
+      if (await fs2.pathExists(defaultClaudeFile)) {
         filesToCompact.push(defaultClaudeFile);
       }
-      if (await fs3.pathExists(defaultAgentsFile)) {
+      if (await fs2.pathExists(defaultAgentsFile)) {
         filesToCompact.push(defaultAgentsFile);
       }
     }
@@ -19857,11 +19977,11 @@ var GitManager = class {
    */
   async updateJunoTaskConfig(gitUrl) {
     const configPath = path3.join(this.workingDirectory, ".juno_task", "init.md");
-    if (!await fs3.pathExists(configPath)) {
+    if (!await fs2.pathExists(configPath)) {
       return;
     }
     try {
-      let content = await fs3.readFile(configPath, "utf-8");
+      let content = await fs2.readFile(configPath, "utf-8");
       const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (frontmatterMatch) {
         let frontmatter = frontmatterMatch[1];
@@ -19882,7 +20002,7 @@ GIT_URL: ${gitUrl}
 `;
         content = frontmatter + content;
       }
-      await fs3.writeFile(configPath, content, "utf-8");
+      await fs2.writeFile(configPath, content, "utf-8");
     } catch (error) {
       console.warn(`Warning: Failed to update juno-code configuration: ${error}`);
     }
@@ -21814,6 +21934,11 @@ var QUICK_REFERENCE = [
         description: "Shell completion setup",
         usage: "juno-code completion <install|uninstall>"
       },
+      {
+        name: "services",
+        description: "Manage service scripts (use --force to refresh codex.py/claude.py)",
+        usage: "juno-code services install --force"
+      },
       {
         name: "help",
         description: "Show help information",
@@ -22382,11 +22507,12 @@ init_service_installer();
 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 list          List installed service scripts
-  $ juno-code services status        Check installation status
-  $ juno-code services uninstall     Remove all service scripts
-  $ juno-code services path          Show services directory path
+  $ 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 list               List installed service scripts
+  $ juno-code services status             Check installation status
+  $ juno-code services uninstall          Remove all service scripts
+  $ juno-code services path               Show services directory path
 
 Service scripts are Python/shell scripts that provide additional functionality
 and can be customized by users. They are installed to ~/.juno_code/services/
@@ -22560,7 +22686,7 @@ var ShellDetector = class _ShellDetector {
    * Get shell configuration file path
    */
   getConfigPath(shell) {
-    const homeDir = os3.homedir();
+    const homeDir = os4.homedir();
     switch (shell) {
       case "bash":
         if (process.platform === "darwin") {
@@ -22584,7 +22710,7 @@ var ShellDetector = class _ShellDetector {
    * Get shell completion script installation path
    */
   getCompletionPath(shell) {
-    const homeDir = os3.homedir();
+    const homeDir = os4.homedir();
     switch (shell) {
       case "bash":
         if (process.platform === "darwin") {
@@ -22639,10 +22765,10 @@ autoload -U compinit && compinit`;
    */
   async isSourceCommandPresent(configPath, sourceCommand) {
     try {
-      if (!await fs3.pathExists(configPath)) {
+      if (!await fs2.pathExists(configPath)) {
         return false;
       }
-      const content = await fs3.readFile(configPath, "utf-8");
+      const content = await fs2.readFile(configPath, "utf-8");
       return content.includes("juno-code completion");
     } catch {
       return false;
@@ -22664,15 +22790,15 @@ autoload -U compinit && compinit`;
         continue;
       }
       try {
-        const completionExists = await fs3.pathExists(shell.completionPath);
-        const configExists = await fs3.pathExists(shell.configPath);
+        const completionExists = await fs2.pathExists(shell.completionPath);
+        const configExists = await fs2.pathExists(shell.configPath);
         const isSourced = configExists && await this.isSourceCommandPresent(
           shell.configPath,
           this.getSourceCommand(shell.name, shell.completionPath)
         );
         let lastInstalled;
         if (completionExists) {
-          const stats = await fs3.stat(shell.completionPath);
+          const stats = await fs2.stat(shell.completionPath);
           lastInstalled = stats.mtime;
         }
         statuses.push({
@@ -22698,7 +22824,7 @@ autoload -U compinit && compinit`;
   async ensureCompletionDirectory(shell) {
     const completionPath = this.getCompletionPath(shell);
     const completionDir = path3.dirname(completionPath);
-    await fs3.ensureDir(completionDir);
+    await fs2.ensureDir(completionDir);
   }
   /**
    * Ensure directory exists for shell configuration
@@ -22706,7 +22832,7 @@ autoload -U compinit && compinit`;
   async ensureConfigDirectory(shell) {
     const configPath = this.getConfigPath(shell);
     const configDir = path3.dirname(configPath);
-    await fs3.ensureDir(configDir);
+    await fs2.ensureDir(configDir);
   }
   /**
    * Get shell version information
@@ -22730,15 +22856,15 @@ autoload -U compinit && compinit`;
     try {
       const configPath = this.getConfigPath(shell);
       const configDir = path3.dirname(configPath);
-      await fs3.access(configDir, fs3.constants.W_OK);
+      await fs2.access(configDir, fs2.constants.W_OK);
     } catch {
       issues.push(`Cannot write to ${shell} configuration directory`);
     }
     try {
       const completionPath = this.getCompletionPath(shell);
       const completionDir = path3.dirname(completionPath);
-      await fs3.ensureDir(completionDir);
-      await fs3.access(completionDir, fs3.constants.W_OK);
+      await fs2.ensureDir(completionDir);
+      await fs2.access(completionDir, fs2.constants.W_OK);
     } catch {
       issues.push(`Cannot write to ${shell} completion directory`);
     }
@@ -22809,10 +22935,10 @@ var ContextAwareCompletion = class {
   async getSessionIds() {
     try {
       const sessionDir = path3.join(process.cwd(), ".juno_task", "sessions");
-      if (!await fs3.pathExists(sessionDir)) {
+      if (!await fs2.pathExists(sessionDir)) {
         return [];
       }
-      const sessions = await fs3.readdir(sessionDir);
+      const sessions = await fs2.readdir(sessionDir);
       return sessions.filter((name) => name.match(/^session_\d+$/)).map((name) => name.replace("session_", "")).sort((a, b) => parseInt(b) - parseInt(a));
     } catch {
       return [];
@@ -22826,8 +22952,8 @@ var ContextAwareCompletion = class {
       const builtinTemplates = ["basic", "advanced", "research", "development"];
       const customTemplatesDir = path3.join(process.cwd(), ".juno_task", "templates");
       let customTemplates = [];
-      if (await fs3.pathExists(customTemplatesDir)) {
-        const files = await fs3.readdir(customTemplatesDir);
+      if (await fs2.pathExists(customTemplatesDir)) {
+        const files = await fs2.readdir(customTemplatesDir);
         customTemplates = files.filter((name) => name.endsWith(".md") || name.endsWith(".hbs")).map((name) => path3.basename(name, path3.extname(name)));
       }
       return [...builtinTemplates, ...customTemplates].sort();
@@ -22862,7 +22988,7 @@ var ContextAwareCompletion = class {
    */
   expandPath(inputPath) {
     if (inputPath.startsWith("~/")) {
-      return path3.join(os3.homedir(), inputPath.slice(2));
+      return path3.join(os4.homedir(), inputPath.slice(2));
     }
     if (inputPath.startsWith("./") || inputPath.startsWith("../")) {
       return path3.resolve(inputPath);
@@ -22904,7 +23030,7 @@ var CompletionInstaller = class {
       await this.shellDetector.ensureConfigDirectory(shell);
       const script = this.generateEnhancedCompletion(shell, "juno-code");
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      await fs3.writeFile(completionPath, script, "utf-8");
+      await fs2.writeFile(completionPath, script, "utf-8");
       const configPath = this.shellDetector.getConfigPath(shell);
       const sourceCommand = this.shellDetector.getSourceCommand(shell, completionPath);
       const warnings = [];
@@ -22912,7 +23038,7 @@ var CompletionInstaller = class {
         const isPresent = await this.shellDetector.isSourceCommandPresent(configPath, sourceCommand);
         if (!isPresent) {
           try {
-            await fs3.appendFile(configPath, `
+            await fs2.appendFile(configPath, `
 
 ${sourceCommand}
 `);
@@ -22943,8 +23069,8 @@ ${sourceCommand}
   async uninstall(shell) {
     try {
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      if (await fs3.pathExists(completionPath)) {
-        await fs3.remove(completionPath);
+      if (await fs2.pathExists(completionPath)) {
+        await fs2.remove(completionPath);
         return true;
       }
       return false;
@@ -22958,7 +23084,7 @@ ${sourceCommand}
   async isInstalled(shell) {
     try {
       const completionPath = this.shellDetector.getCompletionPath(shell);
-      return await fs3.pathExists(completionPath);
+      return await fs2.pathExists(completionPath);
     } catch {
       return false;
     }