juno-code 1.0.49 → 1.0.51

package/dist/index.mjs

@@ -34,7 +34,7 @@ var __export = (target, all) => {
 var version;
 var init_version = __esm({
   "src/version.ts"() {
-    version = "1.0.49";
+    version = "1.0.51";
   }
 });
 
@@ -985,6 +985,9 @@ var init_shell_backend = __esm({
             args.push("--disallowedTools");
             args.push(...request.arguments.disallowedTools);
           }
+          if (isPython && request.arguments?.thinking) {
+            args.push("--thinking", String(request.arguments.thinking));
+          }
           if (isPython && request.arguments?.resume) {
             args.push("--resume", String(request.arguments.resume));
           }
@@ -994,6 +997,9 @@ var init_shell_backend = __esm({
           if (isPython && subagentType === "pi" && request.arguments?.project_path) {
             args.push("--cd", String(request.arguments.project_path));
           }
+          if (isPython && subagentType === "pi" && request.arguments?.live === true) {
+            args.push("--live");
+          }
           if (isPython && this.config.debug) {
             args.push("--verbose");
           }
@@ -1011,12 +1017,19 @@ var init_shell_backend = __esm({
               `Environment variables: ${Object.keys(env2).filter((k) => k.startsWith("JUNO_") || k.startsWith("PI_")).join(", ")}`
             );
           }
+          const isPiLiveMode = isPython && subagentType === "pi" && request.arguments?.live === true;
+          const shouldAttachLiveTerminal = isPiLiveMode && process.stdout.isTTY === true;
+          if (this.config.debug && isPiLiveMode) {
+            engineLogger.debug(
+              `Pi live mode stdio: ${shouldAttachLiveTerminal ? "inherit (interactive TTY or stdout-tty fallback)" : "pipe (headless/non-TTY)"}`
+            );
+          }
           const child = spawn(command, args, {
             env: env2,
             cwd: this.config.workingDirectory,
-            stdio: ["pipe", "pipe", "pipe"]
+            stdio: shouldAttachLiveTerminal ? "inherit" : ["pipe", "pipe", "pipe"]
           });
-          if (child.stdin) {
+          if (!shouldAttachLiveTerminal && child.stdin) {
             child.stdin.end();
           }
           let stdout2 = "";
@@ -1088,7 +1101,8 @@ var init_shell_backend = __esm({
                     subAgentResponse = JSON.parse(captured);
                   }
                 } catch (error) {
-                  if (this.config?.debug) {
+                  const isNotFound = error?.code === "ENOENT";
+                  if (!isNotFound && this.config?.debug) {
                     engineLogger.warn(
                       `Failed to read subagent capture: ${error instanceof Error ? error.message : String(error)}`
                     );
@@ -1299,6 +1313,8 @@ var init_shell_backend = __esm({
                 delete inner.type;
                 sanitizedPiEvent.sub_agent_response = inner;
               }
+              const usage = piEvent.usage;
+              const totalCostUsd = typeof piEvent.total_cost_usd === "number" ? piEvent.total_cost_usd : typeof usage?.cost?.total === "number" ? usage.cost.total : void 0;
               const structuredPayload = {
                 type: "result",
                 subtype: piEvent.subtype || (isError ? "error" : "success"),
@@ -1309,7 +1325,8 @@ var init_shell_backend = __esm({
                 session_id: piEvent.session_id,
                 exit_code: result.exitCode,
                 duration_ms: piEvent.duration_ms ?? result.duration,
-                usage: piEvent.usage,
+                total_cost_usd: totalCostUsd,
+                usage,
                 sub_agent_response: sanitizedPiEvent
               };
               const metadata = {
@@ -1700,6 +1717,16 @@ function getDefaultHooksJson(indent = 2) {
   return JSON.stringify(DEFAULT_HOOKS, null, indent);
 }
 
+// src/core/subagent-models.ts
+init_version();
+var SUBAGENT_DEFAULT_MODELS = {
+  claude: ":sonnet",
+  codex: ":codex",
+  gemini: ":pro",
+  cursor: "auto",
+  pi: ":pi"
+};
+
 // src/core/config.ts
 var ENV_VAR_MAPPING = {
   // Core settings
@@ -1749,18 +1776,31 @@ var JunoTaskConfigSchema = z.object({
   defaultBackend: BackendTypeSchema.describe("Default backend to use for task execution"),
   defaultMaxIterations: z.number().int().min(1).max(1e3).describe("Default maximum number of iterations for task execution"),
   defaultModel: z.string().optional().describe("Default model to use for the subagent"),
+  defaultModels: z.record(SubagentTypeSchema, z.string()).optional().describe("Optional per-subagent default model overrides"),
   // Project metadata
   mainTask: z.string().optional().describe("Main task objective for the project"),
   // Logging settings
   logLevel: LogLevelSchema.describe("Logging level for the application"),
   logFile: z.string().optional().describe("Path to log file (optional)"),
-  verbose: z.boolean().describe("Enable verbose output"),
+  verbose: z.preprocess(
+    (val) => {
+      if (val === true) return 1;
+      if (val === false) return 0;
+      if (typeof val === "string") {
+        const lower = val.toLowerCase().trim();
+        if (lower === "true" || lower === "yes") return 1;
+        if (lower === "false" || lower === "no") return 0;
+      }
+      return val;
+    },
+    z.number().int().min(0).max(2)
+  ).describe("Verbosity level: 0=quiet, 1=normal+helping texts (default), 2=debug+hooks"),
   quiet: z.boolean().describe("Enable quiet mode (minimal output)"),
   // MCP settings
   mcpTimeout: z.number().int().min(1e3).max(864e5).describe("MCP server timeout in milliseconds"),
   mcpRetries: z.number().int().min(0).max(10).describe("Number of retries for MCP operations"),
   mcpServerPath: z.string().optional().describe("Path to MCP server executable (auto-discovered if not specified)"),
-  mcpServerName: z.string().optional().describe('Named MCP server to connect to (e.g., "roundtable-ai")'),
+  mcpServerName: z.string().optional().describe("Named MCP server to connect to"),
   // Hook settings
   hookCommandTimeout: z.number().int().min(1e3).max(36e5).optional().describe(
     "Timeout for individual hook commands in milliseconds (default: 300000 = 5 minutes)"
@@ -1775,6 +1815,11 @@ var JunoTaskConfigSchema = z.object({
   // Paths
   workingDirectory: z.string().describe("Working directory for task execution"),
   sessionDirectory: z.string().describe("Directory for storing session data"),
+  // Project environment bootstrap
+  envFilePath: z.string().optional().describe(
+    "Path to the project env file loaded before execution (relative to project root or absolute)"
+  ),
+  envFileCopied: z.boolean().optional().describe("Tracks whether configured env file has been initialized from .env.juno"),
   // Hooks configuration
   hooks: HooksSchema.describe(
     "Hook system configuration for executing commands at specific lifecycle events"
@@ -1787,16 +1832,15 @@ var DEFAULT_CONFIG = {
   defaultSubagent: "claude",
   defaultBackend: "shell",
   defaultMaxIterations: 1,
+  defaultModels: { ...SUBAGENT_DEFAULT_MODELS },
   // Logging settings
   logLevel: "info",
-  verbose: false,
+  verbose: 1,
   quiet: false,
   // MCP settings (also used by shell backend)
   mcpTimeout: 432e5,
   // 43200 seconds (12 hours) - default for long-running shell backend operations
   mcpRetries: 3,
-  mcpServerName: "roundtable-ai",
-  // Default to roundtable-ai server
   // Quota/hourly limit settings
   onHourlyLimit: "raise",
   // Default to exit immediately when hourly limit is reached
@@ -1806,6 +1850,9 @@ var DEFAULT_CONFIG = {
   // Paths
   workingDirectory: process.cwd(),
   sessionDirectory: path4.join(process.cwd(), ".juno_task"),
+  // Project environment bootstrap
+  envFilePath: ".env.juno",
+  envFileCopied: false,
   // Hooks configuration - populated with default hooks template
   hooks: getDefaultHooks()
 };
@@ -1818,6 +1865,7 @@ var GLOBAL_CONFIG_FILE_NAMES = [
   // Will look for 'junoCode' field
 ];
 var PROJECT_CONFIG_FILE = ".juno_task/config.json";
+var DEFAULT_PROJECT_ENV_FILE = ".env.juno";
 function resolvePath(inputPath, basePath = process.cwd()) {
   if (path4.isAbsolute(inputPath)) {
     return inputPath;
@@ -1839,7 +1887,12 @@ function loadConfigFromEnv() {
   for (const [envVar, configKey] of Object.entries(ENV_VAR_MAPPING)) {
     const value = process.env[envVar];
     if (value !== void 0) {
-      config[configKey] = parseEnvValue(value);
+      let parsed = parseEnvValue(value);
+      if (configKey === "verbose") {
+        if (parsed === true) parsed = 1;
+        else if (parsed === false) parsed = 0;
+      }
+      config[configKey] = parsed;
     }
   }
   return config;
@@ -2073,6 +2126,95 @@ function validateConfig(config) {
     throw error;
   }
 }
+function parseEnvFileContent(content) {
+  const envVars = {};
+  const lines = content.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const trimmedLine = rawLine.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const line = trimmedLine.startsWith("export ") ? trimmedLine.slice(7).trim() : trimmedLine;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      continue;
+    }
+    let value = line.slice(separatorIndex + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) && value.length >= 2) {
+      const quote = value[0];
+      value = value.slice(1, -1);
+      if (quote === '"') {
+        value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+      }
+    } else {
+      const inlineCommentIndex = value.indexOf(" #");
+      if (inlineCommentIndex >= 0) {
+        value = value.slice(0, inlineCommentIndex).trimEnd();
+      }
+    }
+    envVars[key] = value;
+  }
+  return envVars;
+}
+async function loadEnvFileIntoProcess(envFilePath) {
+  try {
+    const content = await promises.readFile(envFilePath, "utf-8");
+    const parsed = parseEnvFileContent(content);
+    for (const [key, value] of Object.entries(parsed)) {
+      process.env[key] = value;
+    }
+  } catch (error) {
+    console.warn(`Warning: Failed to load env file ${envFilePath}: ${error}`);
+  }
+}
+async function ensureAndLoadProjectEnv(baseDir) {
+  const configPath = path4.join(baseDir, PROJECT_CONFIG_FILE);
+  const defaultEnvPath = resolvePath(DEFAULT_PROJECT_ENV_FILE, baseDir);
+  await fs.ensureFile(defaultEnvPath);
+  let existingConfig = null;
+  if (await fs.pathExists(configPath)) {
+    try {
+      existingConfig = await fs.readJson(configPath);
+    } catch (error) {
+      console.warn(`Warning: Failed to read ${configPath} for env bootstrap: ${error}`);
+    }
+  }
+  const configuredEnvPathRaw = existingConfig && typeof existingConfig.envFilePath === "string" && existingConfig.envFilePath ? existingConfig.envFilePath : DEFAULT_PROJECT_ENV_FILE;
+  const configuredEnvPath = resolvePath(configuredEnvPathRaw, baseDir);
+  let envFileCopied = existingConfig && typeof existingConfig.envFileCopied === "boolean" ? existingConfig.envFileCopied : false;
+  let needsConfigUpdate = false;
+  if (configuredEnvPath !== defaultEnvPath) {
+    const configuredExists = await fs.pathExists(configuredEnvPath);
+    if (!configuredExists) {
+      await fs.ensureDir(path4.dirname(configuredEnvPath));
+      if (!envFileCopied) {
+        await promises.copyFile(defaultEnvPath, configuredEnvPath);
+      } else {
+        await fs.ensureFile(configuredEnvPath);
+      }
+    }
+    if (!envFileCopied) {
+      envFileCopied = true;
+      needsConfigUpdate = true;
+    }
+  }
+  if (existingConfig && (needsConfigUpdate || typeof existingConfig.envFilePath !== "string" || typeof existingConfig.envFileCopied !== "boolean")) {
+    const updatedConfig = {
+      ...existingConfig,
+      envFilePath: configuredEnvPathRaw,
+      envFileCopied
+    };
+    await fs.writeJson(configPath, updatedConfig, { spaces: 2 });
+  }
+  await loadEnvFileIntoProcess(defaultEnvPath);
+  if (configuredEnvPath !== defaultEnvPath) {
+    await loadEnvFileIntoProcess(configuredEnvPath);
+  }
+}
 async function ensureHooksConfig(baseDir) {
   try {
     const configDir = path4.join(baseDir, ".juno_task");
@@ -2095,19 +2237,30 @@ async function ensureHooksConfig(baseDir) {
       }
       if (!existingConfig.defaultModel) {
         const subagent = existingConfig.defaultSubagent || "claude";
-        const modelDefaults = {
-          claude: ":sonnet",
-          codex: ":codex",
-          gemini: ":pro",
-          cursor: "auto"
-        };
-        existingConfig.defaultModel = modelDefaults[subagent] || ":sonnet";
+        existingConfig.defaultModel = SUBAGENT_DEFAULT_MODELS[subagent] || SUBAGENT_DEFAULT_MODELS.claude;
+        needsUpdate = true;
+      }
+      if (!existingConfig.defaultModels || typeof existingConfig.defaultModels !== "object" || Array.isArray(existingConfig.defaultModels)) {
+        const baseDefaults = { ...SUBAGENT_DEFAULT_MODELS };
+        const subagent = existingConfig.defaultSubagent || "claude";
+        if (typeof existingConfig.defaultModel === "string") {
+          baseDefaults[subagent] = existingConfig.defaultModel;
+        }
+        existingConfig.defaultModels = baseDefaults;
         needsUpdate = true;
       }
       if (existingConfig.defaultMaxIterations === 50) {
         existingConfig.defaultMaxIterations = DEFAULT_CONFIG.defaultMaxIterations;
         needsUpdate = true;
       }
+      if (!existingConfig.envFilePath) {
+        existingConfig.envFilePath = DEFAULT_PROJECT_ENV_FILE;
+        needsUpdate = true;
+      }
+      if (typeof existingConfig.envFileCopied !== "boolean") {
+        existingConfig.envFileCopied = false;
+        needsUpdate = true;
+      }
       if (needsUpdate) {
         await fs.writeJson(configPath, existingConfig, { spaces: 2 });
       }
@@ -2119,6 +2272,7 @@ async function ensureHooksConfig(baseDir) {
 async function loadConfig(options = {}) {
   const { baseDir = process.cwd(), configFile, cliConfig } = options;
   await ensureHooksConfig(baseDir);
+  await ensureAndLoadProjectEnv(baseDir);
   const loader = new ConfigLoader(baseDir);
   loader.fromEnvironment();
   if (configFile) {
@@ -2151,7 +2305,7 @@ async function executeHook(hookType, hooks, context = {}, options = {}) {
     logContext = "SYSTEM" /* SYSTEM */
   } = options;
   const contextLogger = logger.child(logContext);
-  contextLogger.info(`Starting hook execution: ${hookType}`, {
+  contextLogger.debug(`Starting hook execution: ${hookType}`, {
     context,
     workingDirectory: context.workingDirectory || process.cwd(),
     commandTimeout,
@@ -2180,13 +2334,13 @@ async function executeHook(hookType, hooks, context = {}, options = {}) {
       commandsFailed: 0
     };
   }
-  contextLogger.info(`Executing ${hook.commands.length} commands for hook ${hookType}`);
+  contextLogger.debug(`Executing ${hook.commands.length} commands for hook ${hookType}`);
   const commandResults = [];
   let commandsFailed = 0;
   for (let i = 0; i < hook.commands.length; i++) {
     const command = hook.commands[i];
     const commandStartTime = Date.now();
-    contextLogger.info(`Executing command ${i + 1}/${hook.commands.length}: ${command}`, {
+    contextLogger.debug(`Executing command ${i + 1}/${hook.commands.length}: ${command}`, {
       commandIndex: i,
       totalCommands: hook.commands.length
     });
@@ -2234,7 +2388,7 @@ async function executeHook(hookType, hooks, context = {}, options = {}) {
       };
       commandResults.push(commandResult);
       if (success2) {
-        contextLogger.info(`Command completed successfully`, {
+        contextLogger.debug(`Command completed successfully`, {
           command,
           exitCode: result2.exitCode,
           duration,
@@ -2315,7 +2469,7 @@ async function executeHook(hookType, hooks, context = {}, options = {}) {
     commandsExecuted,
     commandsFailed
   };
-  contextLogger.info(`Hook execution completed`, {
+  contextLogger.debug(`Hook execution completed`, {
     hookType,
     totalDuration,
     commandsExecuted,
@@ -2326,7 +2480,7 @@ async function executeHook(hookType, hooks, context = {}, options = {}) {
 }
 async function executeHooks(hookTypes, hooks, context = {}, options = {}) {
   const results = [];
-  hookLogger.info(`Starting batch hook execution`, {
+  hookLogger.debug(`Starting batch hook execution`, {
     hookTypes,
     context
   });
@@ -2337,7 +2491,7 @@ async function executeHooks(hookTypes, hooks, context = {}, options = {}) {
   const totalSuccess = results.every((r) => r.success);
   const totalCommands = results.reduce((sum, r) => sum + r.commandsExecuted, 0);
   const totalFailed = results.reduce((sum, r) => sum + r.commandsFailed, 0);
-  hookLogger.info(`Batch hook execution completed`, {
+  hookLogger.debug(`Batch hook execution completed`, {
     hookTypes,
     totalHooks: results.length,
     totalCommands,
@@ -2629,6 +2783,30 @@ var ExecutionEngine = class extends EventEmitter {
    */
   setupProgressTracking() {
   }
+  /**
+   * Display hook execution output to stderr at verbose level 2 (debug+hooks).
+   * At level 2: shows hook name, command stdout/stderr output.
+   * At level 0-1: output is suppressed (hooks still execute).
+   */
+  displayHookOutput(hookResult) {
+    if (this.engineConfig.config.verbose < 2) return;
+    for (const cmdResult of hookResult.commandResults) {
+      const prefix = `[hook:${hookResult.hookType}]`;
+      if (cmdResult.stdout) {
+        for (const line of cmdResult.stdout.split("\n")) {
+          if (line.trim()) console.error(`${prefix} ${line}`);
+        }
+      }
+      if (cmdResult.stderr) {
+        for (const line of cmdResult.stderr.split("\n")) {
+          if (line.trim()) console.error(`${prefix} ${line}`);
+        }
+      }
+      if (!cmdResult.success) {
+        console.error(`${prefix} command failed (exit ${cmdResult.exitCode}): ${cmdResult.command}`);
+      }
+    }
+  }
   /**
    * Initialize backend for execution request.
    * Directly creates and configures a ShellBackend (no factory indirection).
@@ -2643,11 +2821,14 @@ var ExecutionEngine = class extends EventEmitter {
     backend.configure({
       workingDirectory: request.workingDirectory,
       servicesPath: `${process.env.HOME || process.env.USERPROFILE}/.juno_code/services`,
-      debug: this.engineConfig.config.verbose,
+      debug: this.engineConfig.config.verbose >= 2,
       timeout: request.timeoutMs || this.engineConfig.config.mcpTimeout || 432e5,
       enableJsonStreaming: true,
-      outputRawJson: this.engineConfig.config.verbose,
-      environment: process.env,
+      outputRawJson: this.engineConfig.config.verbose >= 1,
+      environment: {
+        ...process.env,
+        JUNO_TASK_ROOT: process.env.JUNO_TASK_ROOT || request.workingDirectory
+      },
       sessionId: request.requestId
     });
     await backend.initialize();
@@ -2669,7 +2850,7 @@ var ExecutionEngine = class extends EventEmitter {
         this.emit("progress:error", { event, error });
       }
     });
-    engineLogger.info(`Initialized ${backend.name} backend for execution`);
+    engineLogger.debug(`Initialized ${backend.name} backend for execution`);
   }
   /**
    * Validate execution request parameters
@@ -2772,10 +2953,13 @@ var ExecutionEngine = class extends EventEmitter {
   async executeInternal(context) {
     context.status = "running" /* RUNNING */;
     context.sessionContext = { ...context.sessionContext, state: "active" };
+    if (!process.env.JUNO_TASK_ROOT) {
+      process.env.JUNO_TASK_ROOT = context.request.workingDirectory;
+    }
     await this.initializeBackend(context.request);
     try {
       if (this.engineConfig.config.hooks && !this.engineConfig.config.skipHooks) {
-        await executeHook(
+        const hookResult = await executeHook(
           "START_RUN",
           this.engineConfig.config.hooks,
           {
@@ -2795,6 +2979,7 @@ var ExecutionEngine = class extends EventEmitter {
             commandTimeout: this.engineConfig.config.hookCommandTimeout
           }
         );
+        this.displayHookOutput(hookResult);
       }
     } catch (error) {
       engineLogger.warn("Hook START_RUN failed", { error });
@@ -2818,7 +3003,7 @@ var ExecutionEngine = class extends EventEmitter {
     }
     try {
       if (this.engineConfig.config.hooks && !this.engineConfig.config.skipHooks) {
-        await executeHook(
+        const hookResult = await executeHook(
           "END_RUN",
           this.engineConfig.config.hooks,
           {
@@ -2840,6 +3025,7 @@ var ExecutionEngine = class extends EventEmitter {
             commandTimeout: this.engineConfig.config.hookCommandTimeout
           }
         );
+        this.displayHookOutput(hookResult);
       }
     } catch (error) {
       engineLogger.warn("Hook END_RUN failed", { error });
@@ -2884,7 +3070,7 @@ var ExecutionEngine = class extends EventEmitter {
     const iterationStart = /* @__PURE__ */ new Date();
     try {
       if (this.engineConfig.config.hooks && !this.engineConfig.config.skipHooks) {
-        await executeHook(
+        const hookResult = await executeHook(
           "START_ITERATION",
           this.engineConfig.config.hooks,
           {
@@ -2905,6 +3091,7 @@ var ExecutionEngine = class extends EventEmitter {
             commandTimeout: this.engineConfig.config.hookCommandTimeout
           }
         );
+        this.displayHookOutput(hookResult);
       }
     } catch (error) {
       engineLogger.warn("Hook START_ITERATION failed", { error, iterationNumber });
@@ -2931,6 +3118,8 @@ var ExecutionEngine = class extends EventEmitter {
         ...context.request.continueConversation !== void 0 && {
           continueConversation: context.request.continueConversation
         },
+        ...context.request.thinking !== void 0 && { thinking: context.request.thinking },
+        ...context.request.live !== void 0 && { live: context.request.live },
         iteration: iterationNumber
       },
       timeout: context.request.timeoutMs || this.engineConfig.config.mcpTimeout,
@@ -2967,7 +3156,7 @@ var ExecutionEngine = class extends EventEmitter {
       this.emit("iteration:complete", { context, iterationResult });
       try {
         if (this.engineConfig.config.hooks && !this.engineConfig.config.skipHooks) {
-          await executeHook(
+          const hookResult = await executeHook(
             "END_ITERATION",
             this.engineConfig.config.hooks,
             {
@@ -2989,6 +3178,7 @@ var ExecutionEngine = class extends EventEmitter {
               commandTimeout: this.engineConfig.config.hookCommandTimeout
             }
           );
+          this.displayHookOutput(hookResult);
         }
       } catch (error) {
         engineLogger.warn("Hook END_ITERATION failed", { error, iterationNumber });
@@ -3023,7 +3213,7 @@ var ExecutionEngine = class extends EventEmitter {
       this.emit("iteration:error", { context, iterationResult });
       try {
         if (this.engineConfig.config.hooks && !this.engineConfig.config.skipHooks) {
-          await executeHook(
+          const hookResult = await executeHook(
             "END_ITERATION",
             this.engineConfig.config.hooks,
             {
@@ -3046,6 +3236,7 @@ var ExecutionEngine = class extends EventEmitter {
               commandTimeout: this.engineConfig.config.hookCommandTimeout
             }
           );
+          this.displayHookOutput(hookResult);
         }
       } catch (hookError) {
         engineLogger.warn("Hook END_ITERATION failed", { error: hookError, iterationNumber });
@@ -3521,6 +3712,12 @@ function createExecutionRequest(options) {
   if (options.continueConversation !== void 0) {
     result.continueConversation = options.continueConversation;
   }
+  if (options.thinking !== void 0) {
+    result.thinking = options.thinking;
+  }
+  if (options.live !== void 0) {
+    result.live = options.live;
+  }
   return result;
 }
 
@@ -4200,9 +4397,16 @@ function validateEnvironmentVars(envVars) {
         case "JUNO_TASK_DEFAULT_MAX_ITERATIONS":
           config.defaultMaxIterations = validateIterations(parseInt(value, 10));
           break;
-        case "JUNO_TASK_VERBOSE":
-          config.verbose = value.toLowerCase() === "true";
+        case "JUNO_TASK_VERBOSE": {
+          const lower = value.toLowerCase();
+          if (lower === "true" || lower === "yes") config.verbose = 1;
+          else if (lower === "false" || lower === "no") config.verbose = 0;
+          else {
+            const n = Number(value);
+            config.verbose = !isNaN(n) && n >= 0 && n <= 2 ? Math.floor(n) : 1;
+          }
           break;
+        }
         case "JUNO_TASK_QUIET":
           config.quiet = value.toLowerCase() === "true";
           break;