@moxxy/cli 0.0.7 → 0.0.9

package/dist/index.js

@@ -1045,15 +1045,45 @@ var init_stream_parser = __esm({
         }
         try {
           return JSON.parse(line);
-        } catch (error2) {
+        } catch {
           return null;
         }
       }
       /**
        * Convert stream event to chat stream chunk
+       * Handles both CLI format and API format events
        */
       toChunk(event) {
         switch (event.type) {
+          // --- Claude CLI format events ---
+          case "assistant": {
+            const message = event.message;
+            if (!message?.content) return null;
+            const textBlocks = message.content.filter((b) => b.type === "text");
+            const text = textBlocks.map((b) => b.text || "").join("");
+            const thinkingBlocks = message.content.filter((b) => b.type === "thinking");
+            const thinking = thinkingBlocks.length > 0 ? thinkingBlocks.map((b) => b.thinking || b.text || "").join("") : void 0;
+            if (!text && !thinking) return null;
+            return {
+              content: text,
+              thinking,
+              done: false,
+              sessionKey: this.sessionKey,
+              timestamp: Date.now()
+            };
+          }
+          case "result": {
+            const resultText = event.result || "";
+            return {
+              content: resultText,
+              done: true,
+              sessionKey: this.sessionKey,
+              timestamp: Date.now()
+            };
+          }
+          case "system":
+            return null;
+          // --- Anthropic API format events (legacy/fallback) ---
           case "content_block_delta": {
             const text = event.delta?.text || "";
             return {
@@ -1179,23 +1209,24 @@ var init_chat = __esm({
         });
         this.events.emit("chat:stream:start", sessionKey, agentId);
         options.onStart?.(sessionKey, agentId);
-        let proc = processManager.get(sessionKey);
-        if (!proc) {
-          proc = await processManager.spawn({
-            sessionKey,
-            model: transport.config.model,
-            thinking: options.thinking,
-            permissionMode: transport.config.permissionMode,
-            workingDirectory: transport.config.workingDirectory,
-            timeout: options.timeout
-          });
+        const existingProc = processManager.get(sessionKey);
+        if (existingProc) {
+          processManager.kill(sessionKey);
         }
+        const proc = await processManager.spawn({
+          sessionKey,
+          model: transport.config.model,
+          thinking: options.thinking,
+          permissionMode: transport.config.permissionMode,
+          workingDirectory: transport.config.workingDirectory,
+          timeout: options.timeout,
+          message: options.message,
+          outputFormat: "stream-json"
+        });
         processManager.setStatus(sessionKey, "busy");
         let fullResponse = "";
         let thinking;
         try {
-          proc.process.stdin?.write(options.message + "\n");
-          proc.process.stdin?.end();
           const parser = new ClaudeStreamParser(sessionKey);
           for await (const chunk of parser.parseStream(proc.process.stdout)) {
             if (chunk.content) {
@@ -1371,10 +1402,11 @@ var init_process_manager = __esm({
           );
         }
         const args = this.buildArgs(options);
+        const stdinMode = options.message ? "ignore" : "pipe";
         const proc = (0, import_node_child_process.spawn)(this.config.cliPath, args, {
           cwd: options.workingDirectory || this.config.workingDirectory || process.cwd(),
           env: process.env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: [stdinMode, "pipe", "pipe"]
         });
         const claudeProc = {
           sessionKey: options.sessionKey,
@@ -1392,25 +1424,32 @@ var init_process_manager = __esm({
        * Build CLI arguments
        */
       buildArgs(options) {
+        const outputFormat = options.outputFormat || "json";
         const args = [
           "--print",
-          "--output-format=stream-json",
-          `--session-id=${options.sessionKey}`
+          "--output-format",
+          outputFormat
         ];
+        if (outputFormat === "stream-json") {
+          args.push("--verbose");
+        }
         const model = options.model || this.config.model;
         if (model) {
-          args.push(`--model=${model}`);
+          args.push("--model", model);
         }
         if (options.thinking && options.thinking !== "none") {
-          args.push(`--thinking=${options.thinking}`);
+          args.push("--thinking", options.thinking);
         }
         const permissionMode = options.permissionMode || this.config.permissionMode;
         if (permissionMode) {
-          args.push(`--permission-mode=${permissionMode}`);
+          args.push("--permission-mode", permissionMode);
         }
         const workingDir = options.workingDirectory || this.config.workingDirectory;
         if (workingDir) {
-          args.push(`--add-dir=${workingDir}`);
+          args.push("--add-dir", workingDir);
+        }
+        if (options.message) {
+          args.push(options.message);
         }
         return args;
       }
@@ -1708,7 +1747,6 @@ var init_cli = __esm({
     import_node_util = require("util");
     init_process_manager();
     init_session();
-    init_parsers();
     init_errors2();
     execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
     CLITransport = class {
@@ -1833,6 +1871,7 @@ var init_cli = __esm({
       }
       /**
        * Handle chat.send request
+       * Uses --output-format=json for single-shot responses
        */
       async handleChatSend(options) {
         const sessionKey = options.sessionKey || `claude-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
@@ -1844,26 +1883,37 @@ var init_cli = __esm({
           content: options.message,
           timestamp: Date.now()
         });
-        let proc = this.processManager.get(sessionKey);
-        if (!proc) {
-          proc = await this.processManager.spawn({
-            sessionKey,
-            model: this.config.model,
-            thinking: options.thinking,
-            permissionMode: this.config.permissionMode,
-            workingDirectory: this.config.workingDirectory,
-            timeout
-          });
+        const existingProc = this.processManager.get(sessionKey);
+        if (existingProc) {
+          this.processManager.kill(sessionKey);
         }
+        const proc = await this.processManager.spawn({
+          sessionKey,
+          model: this.config.model,
+          thinking: options.thinking,
+          permissionMode: this.config.permissionMode,
+          workingDirectory: this.config.workingDirectory,
+          timeout,
+          message: options.message,
+          outputFormat: "json"
+        });
         this.processManager.setStatus(sessionKey, "busy");
         try {
-          proc.process.stdin?.write(options.message + "\n");
-          proc.process.stdin?.end();
-          const parser = new ClaudeStreamParser(sessionKey);
-          const { content, thinking } = await Promise.race([
-            parser.collectFullResponse(proc.process.stdout),
+          const output = await Promise.race([
+            this.collectStdout(proc.process),
             this.createTimeoutPromise(timeout)
           ]);
+          let content = "";
+          let thinking;
+          try {
+            const parsed = JSON.parse(output);
+            content = parsed.result || "";
+            if (parsed.thinking) {
+              thinking = parsed.thinking;
+            }
+          } catch {
+            content = output.trim();
+          }
           this.sessionManager.addMessage(sessionKey, {
             role: "assistant",
             content,
@@ -1884,6 +1934,31 @@ var init_cli = __esm({
           throw error2;
         }
       }
+      /**
+       * Collect full stdout from a child process as a string.
+       * Also captures stderr — if the process exits with no stdout, throws with stderr.
+       */
+      collectStdout(proc) {
+        return new Promise((resolve, reject) => {
+          const stdoutChunks = [];
+          const stderrChunks = [];
+          proc.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+          proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+          proc.stdout?.on("error", reject);
+          proc.on("error", reject);
+          proc.on("close", (code) => {
+            const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+            const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+            if (stdout) {
+              resolve(stdout);
+            } else if (code !== 0 || stderr) {
+              reject(new Error(`Claude CLI exited with code ${code}${stderr ? `: ${stderr}` : ""}`));
+            } else {
+              resolve("");
+            }
+          });
+        });
+      }
       /**
        * Handle sessions.list request
        */
@@ -3488,7 +3563,7 @@ var init_dist2 = __esm({
               if (event.message?.content) {
                 const content = event.message.content;
                 if (Array.isArray(content)) {
-                  fullResponse = content.map((c) => c.text || "").join("");
+                  fullResponse = content.map((c2) => c2.text || "").join("");
                 } else if (typeof content === "string") {
                   fullResponse = content;
                 }
@@ -5513,7 +5588,7 @@ var require_logger = __commonJS({
         return level;
       },
       // Can be overridden in the host environment
-      log: function log3(level) {
+      log: function log4(level) {
         level = logger.lookupLevel(level);
         if (typeof console !== "undefined" && logger.lookupLevel(logger.level) <= level) {
           var method = logger.methodMap[level];
@@ -5707,8 +5782,8 @@ var require_base = __commonJS({
         _internalProtoAccess.resetLoggedProperties();
       }
     };
-    var log3 = _logger2["default"].log;
-    exports2.log = log3;
+    var log4 = _logger2["default"].log;
+    exports2.log = log4;
     exports2.createFrame = _utils.createFrame;
     exports2.logger = _logger2["default"];
   }
@@ -6614,8 +6689,8 @@ var require_parser = __commonJS({
           },
           showPosition: function showPosition() {
             var pre = this.pastInput();
-            var c = new Array(pre.length + 1).join("-");
-            return pre + this.upcomingInput() + "\n" + c + "^";
+            var c2 = new Array(pre.length + 1).join("-");
+            return pre + this.upcomingInput() + "\n" + c2 + "^";
           },
           next: function next() {
             if (this.done) {
@@ -8738,8 +8813,8 @@ var require_source_map_consumer = __commonJS({
       }
     });
     SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
-      var c = aStr.charAt(index);
-      return c === ";" || c === ",";
+      var c2 = aStr.charAt(index);
+      return c2 === ";" || c2 === ",";
     };
     SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
       throw new Error("Subclasses must implement _parseMappings");
@@ -10424,19 +10499,19 @@ var require_javascript_compiler = __commonJS({
         }
       },
       replaceStack: function replaceStack(callback) {
-        var prefix = ["("], stack = void 0, createdStack = void 0, usedLiteral = void 0;
+        var prefix2 = ["("], stack = void 0, createdStack = void 0, usedLiteral = void 0;
         if (!this.isInline()) {
           throw new _exception2["default"]("replaceStack on non-inline");
         }
         var top = this.popStack(true);
         if (top instanceof Literal) {
           stack = [top.value];
-          prefix = ["(", stack];
+          prefix2 = ["(", stack];
           usedLiteral = true;
         } else {
           createdStack = true;
           var _name = this.incrStack();
-          prefix = ["((", this.push(_name), " = ", top, ")"];
+          prefix2 = ["((", this.push(_name), " = ", top, ")"];
           stack = this.topStack();
         }
         var item = callback.call(this, stack);
@@ -10446,7 +10521,7 @@ var require_javascript_compiler = __commonJS({
         if (createdStack) {
           this.stackSlot--;
         }
-        this.push(prefix.concat(item, ")"));
+        this.push(prefix2.concat(item, ")"));
       },
       incrStack: function incrStack() {
         this.stackSlot++;
@@ -10979,22 +11054,22 @@ function formatArgs(args) {
     return String(arg);
   }).join(" ");
 }
-function formatLogMessage(level, prefix, message, args, category = "agent") {
+function formatLogMessage(level, prefix2, message, args, category = "agent") {
   const { reset, dim, blue, gray } = ANSI_COLORS;
   const levelColor = LEVEL_COLORS[level];
   const levelName = LEVEL_NAMES[level];
   const time = `${dim}${formatTime5()}${reset}`;
   const levelStr = `${levelColor}${levelName}${reset}`;
-  const ctx = `${blue}[${prefix}]${reset}`;
+  const ctx = `${blue}[${prefix2}]${reset}`;
   const cat = `${gray}[${category}]${reset}`;
   const argsStr = args.length > 0 ? ` ${dim}${formatArgs(args)}${reset}` : "";
   return `${time} ${levelStr} ${ctx}${cat} ${message}${argsStr}`;
 }
-function createAgentLogger(prefix, category = "agent") {
-  return new ConsoleLogger(prefix, category);
+function createAgentLogger(prefix2, category = "agent") {
+  return new ConsoleLogger(prefix2, category);
 }
-function log(level, prefix, message, ...args) {
-  const formatted = formatLogMessage(level, prefix, message, args);
+function log(level, prefix2, message, ...args) {
+  const formatted = formatLogMessage(level, prefix2, message, args);
   switch (level) {
     case "debug":
       console.debug(formatted);
@@ -11048,11 +11123,11 @@ function createCustomAgent(type, id) {
 function formatTime6() {
   return (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
 }
-function log2(level, prefix, message) {
+function log2(level, prefix2, message) {
   const time = `${colors5.dim}${formatTime6()}${colors5.reset}`;
   const levelColor = level === "ERROR" ? colors5.red : colors5.cyan;
   const levelStr = `${levelColor}${level === "INFO" ? "INFO " : "ERROR"}${colors5.reset}`;
-  const ctx = `${colors5.blue}[${prefix}]${colors5.reset}`;
+  const ctx = `${colors5.blue}[${prefix2}]${colors5.reset}`;
   const consoleFn = level === "ERROR" ? console.error : console.info;
   consoleFn(`${time} ${levelStr} ${ctx}${colors5.gray}[agent]${colors5.reset} ${message}`);
 }
@@ -11841,7 +11916,7 @@ Return the authentication confirmation.`;
           prompt: `Please redo the previous work. Reason: ${reason}
 
 ${constraints.length > 0 ? `Constraints:
-${constraints.map((c) => `- ${c}`).join("\n")}` : ""}`
+${constraints.map((c2) => `- ${c2}`).join("\n")}` : ""}`
         };
       }
       /**
@@ -13375,8 +13450,8 @@ git stash drop
        * @param prefix - Context prefix (e.g., agent name)
        * @param category - Log category (default: 'agent')
        */
-      constructor(prefix, category = "agent") {
-        this.prefix = prefix;
+      constructor(prefix2, category = "agent") {
+        this.prefix = prefix2;
         this.category = category;
       }
       category;
@@ -13820,7 +13895,7 @@ ${code}
         parts.push(...this.sections);
         if (this.constraints.length > 0) {
           parts.push("## Constraints\n");
-          parts.push(this.constraints.map((c) => `- ${c}`).join("\n"));
+          parts.push(this.constraints.map((c2) => `- ${c2}`).join("\n"));
         }
         if (this.outputFormats.length > 0) {
           parts.push("\n## Expected Output\n");
@@ -16475,8 +16550,8 @@ Your PRDs should include:
       }
     };
     LoggingHook = class {
-      constructor(prefix = "Agent") {
-        this.prefix = prefix;
+      constructor(prefix2 = "Agent") {
+        this.prefix = prefix2;
       }
       async beforeInitialize(agent) {
         log2("INFO", this.prefix, `Initializing agent: ${agent.name}`);
@@ -17375,6 +17450,122 @@ var init_repo = __esm({
   }
 });
 
+// src/utils/pipeline-logger.ts
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function prefix(issueKey) {
+  return `${import_chalk3.default.magenta("[Pipeline]")} ${import_chalk3.default.cyan(issueKey)}`;
+}
+var import_chalk3, import_ora2, STAGE_LABELS, SpinnerPipelineLogger;
+var init_pipeline_logger = __esm({
+  "src/utils/pipeline-logger.ts"() {
+    "use strict";
+    import_chalk3 = __toESM(require("chalk"));
+    import_ora2 = __toESM(require("ora"));
+    STAGE_LABELS = {
+      triage: "Classifying issue",
+      research: "Researching codebase",
+      inspect: "Inspecting files",
+      plan: "Planning implementation",
+      implement: "Implementing changes"
+    };
+    SpinnerPipelineLogger = class {
+      spinner = null;
+      stageIndex = 0;
+      totalStages = 0;
+      pipelineStart(issueKey, title, stages, skipped) {
+        this.stageIndex = 0;
+        this.totalStages = stages.length;
+        console.log();
+        console.log(
+          `${prefix(issueKey)} ${import_chalk3.default.bold("Pipeline started")} \u2014 ${title}`
+        );
+        const flow = stages.map((s) => import_chalk3.default.bold(s)).join(import_chalk3.default.dim(" \u2192 "));
+        const skipNote = skipped.length ? import_chalk3.default.dim(` (skipped: ${skipped.join(", ")})`) : "";
+        console.log(`${prefix(issueKey)} ${flow}${skipNote}`);
+      }
+      stageStart(issueKey, stage) {
+        this.stageIndex++;
+        const label = STAGE_LABELS[stage] || stage;
+        const progress = import_chalk3.default.dim(`[${this.stageIndex}/${this.totalStages}]`);
+        if (this.spinner) {
+          this.spinner.stop();
+          this.spinner = null;
+        }
+        this.spinner = (0, import_ora2.default)({
+          text: `${prefix(issueKey)} ${progress} ${label}...`,
+          color: "cyan"
+        }).start();
+      }
+      stageSkip(issueKey, stage) {
+        console.log(
+          `${prefix(issueKey)} ${import_chalk3.default.gray("SKIP")} ${import_chalk3.default.dim(stage)} \u2014 using defaults`
+        );
+      }
+      stageComplete(issueKey, stage, durationMs) {
+        const duration = import_chalk3.default.dim(`(${formatDuration(durationMs)})`);
+        if (this.spinner) {
+          this.spinner.succeed(
+            `${prefix(issueKey)} ${import_chalk3.default.bold(stage)} ${import_chalk3.default.green("completed")} ${duration}`
+          );
+          this.spinner = null;
+        } else {
+          console.log(
+            `${prefix(issueKey)} ${import_chalk3.default.green("\u2714")} ${import_chalk3.default.bold(stage)} completed ${duration}`
+          );
+        }
+      }
+      stageFail(issueKey, stage, error2, durationMs) {
+        const duration = import_chalk3.default.dim(`(${formatDuration(durationMs)})`);
+        if (this.spinner) {
+          this.spinner.fail(
+            `${prefix(issueKey)} ${import_chalk3.default.bold(stage)} ${import_chalk3.default.red("failed")} ${duration} \u2014 ${error2}`
+          );
+          this.spinner = null;
+        } else {
+          console.log(
+            `${prefix(issueKey)} ${import_chalk3.default.red("\u2716")} ${import_chalk3.default.bold(stage)} failed ${duration} \u2014 ${error2}`
+          );
+        }
+      }
+      info(issueKey, message) {
+        const wasSpinning = this.spinner?.isSpinning;
+        if (wasSpinning) this.spinner.stop();
+        console.log(`${prefix(issueKey)} ${import_chalk3.default.dim(message)}`);
+        if (wasSpinning) this.spinner.start();
+      }
+      pipelineComplete(issueKey, durationMs, prNumber, branch) {
+        if (this.spinner) {
+          this.spinner.stop();
+          this.spinner = null;
+        }
+        console.log();
+        console.log(
+          `${prefix(issueKey)} ${import_chalk3.default.green.bold("\u2714 Pipeline completed")} in ${import_chalk3.default.bold(formatDuration(durationMs))} \u2014 PR ${import_chalk3.default.cyan(`#${prNumber}`)} on ${import_chalk3.default.cyan(branch)}`
+        );
+        console.log();
+      }
+      pipelineFail(issueKey, durationMs, error2) {
+        if (this.spinner) {
+          this.spinner.stop();
+          this.spinner = null;
+        }
+        console.log();
+        console.log(
+          `${prefix(issueKey)} ${import_chalk3.default.red.bold("\u2716 Pipeline failed")} after ${import_chalk3.default.bold(formatDuration(durationMs))} \u2014 ${error2}`
+        );
+        console.log();
+      }
+    };
+  }
+});
+
 // ../integration-base/dist/index.mjs
 var dist_exports3 = {};
 __export(dist_exports3, {
@@ -17839,8 +18030,8 @@ function encodeReserved(str) {
   }).join("");
 }
 function encodeUnreserved(str) {
-  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
-    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c2) {
+    return "%" + c2.charCodeAt(0).toString(16).toUpperCase();
   });
 }
 function encodeValue(operator, value, key) {
@@ -18216,7 +18407,7 @@ async function fetchWrapper(requestOptions) {
       "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
     );
   }
-  const log3 = requestOptions.request?.log || console;
+  const log4 = requestOptions.request?.log || console;
   const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
   const body = isPlainObject2(requestOptions.body) || Array.isArray(requestOptions.body) ? JSON.stringify(requestOptions.body) : requestOptions.body;
   const requestHeaders = Object.fromEntries(
@@ -18274,7 +18465,7 @@ async function fetchWrapper(requestOptions) {
   if ("deprecation" in responseHeaders) {
     const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
     const deprecationLink = matches && matches.pop();
-    log3.warn(
+    log4.warn(
       `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
     );
   }
@@ -22042,7 +22233,7 @@ var init_html = __esm({
       } else {
         buffer = [str];
       }
-      const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+      const resStr = Promise.all(callbacks.map((c2) => c2({ phase, buffer, context }))).then(
         (res) => Promise.all(
           res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
         ).then(() => buffer[0])
@@ -22503,16 +22694,16 @@ var init_hono_base = __esm({
     init_router();
     init_constants2();
     init_url();
-    notFoundHandler = (c) => {
-      return c.text("404 Not Found", 404);
+    notFoundHandler = (c2) => {
+      return c2.text("404 Not Found", 404);
     };
-    errorHandler = (err, c) => {
+    errorHandler = (err, c2) => {
       if ("getResponse" in err) {
         const res = err.getResponse();
-        return c.newResponse(res.body, res);
+        return c2.newResponse(res.body, res);
       }
       console.error(err);
-      return c.text("Internal Server Error", 500);
+      return c2.text("Internal Server Error", 500);
     };
     Hono = class _Hono {
       get;
@@ -22614,7 +22805,7 @@ var init_hono_base = __esm({
           if (app.errorHandler === errorHandler) {
             handler2 = r.handler;
           } else {
-            handler2 = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+            handler2 = async (c2, next) => (await compose([], app.errorHandler)(c2, () => r.handler(c2, next))).res;
             handler2[COMPOSED_HANDLER] = r.handler;
           }
           subApp.#addRoute(r.method, r.path, handler2);
@@ -22725,16 +22916,16 @@ var init_hono_base = __esm({
             }
           }
         }
-        const getOptions = optionHandler ? (c) => {
-          const options2 = optionHandler(c);
+        const getOptions = optionHandler ? (c2) => {
+          const options2 = optionHandler(c2);
           return Array.isArray(options2) ? options2 : [options2];
-        } : (c) => {
+        } : (c2) => {
           let executionContext = void 0;
           try {
-            executionContext = c.executionCtx;
+            executionContext = c2.executionCtx;
           } catch {
           }
-          return [c.env, executionContext];
+          return [c2.env, executionContext];
         };
         replaceRequest ||= (() => {
           const mergedPath = mergePath(this._basePath, path);
@@ -22745,8 +22936,8 @@ var init_hono_base = __esm({
             return new Request(url, request2);
           };
         })();
-        const handler2 = async (c, next) => {
-          const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+        const handler2 = async (c2, next) => {
+          const res = await applicationHandler(replaceRequest(c2.req.raw), ...getOptions(c2));
           if (res) {
             return res;
           }
@@ -22762,9 +22953,9 @@ var init_hono_base = __esm({
         this.router.add(method, path, [handler2, r]);
         this.routes.push(r);
       }
-      #handleError(err, c) {
+      #handleError(err, c2) {
         if (err instanceof Error) {
-          return this.errorHandler(err, c);
+          return this.errorHandler(err, c2);
         }
         throw err;
       }
@@ -22774,7 +22965,7 @@ var init_hono_base = __esm({
         }
         const path = this.getPath(request2, { env });
         const matchResult = this.router.match(method, path);
-        const c = new Context(request2, {
+        const c2 = new Context(request2, {
           path,
           matchResult,
           env,
@@ -22784,20 +22975,20 @@ var init_hono_base = __esm({
         if (matchResult[0].length === 1) {
           let res;
           try {
-            res = matchResult[0][0][0][0](c, async () => {
-              c.res = await this.#notFoundHandler(c);
+            res = matchResult[0][0][0][0](c2, async () => {
+              c2.res = await this.#notFoundHandler(c2);
             });
           } catch (err) {
-            return this.#handleError(err, c);
+            return this.#handleError(err, c2);
           }
           return res instanceof Promise ? res.then(
-            (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
-          ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+            (resolved) => resolved || (c2.finalized ? c2.res : this.#notFoundHandler(c2))
+          ).catch((err) => this.#handleError(err, c2)) : res ?? this.#notFoundHandler(c2);
         }
         const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
         return (async () => {
           try {
-            const context = await composed(c);
+            const context = await composed(c2);
             if (!context.finalized) {
               throw new Error(
                 "Context is not finalized. Did you forget to return a Response object or `await next()`?"
@@ -22805,7 +22996,7 @@ var init_hono_base = __esm({
             }
             return context.res;
           } catch (err) {
-            return this.#handleError(err, c);
+            return this.#handleError(err, c2);
           }
         })();
       }
@@ -22999,8 +23190,8 @@ var init_node = __esm({
       buildRegExpStr() {
         const childKeys = Object.keys(this.#children).sort(compareKey);
         const strList = childKeys.map((k) => {
-          const c = this.#children[k];
-          return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+          const c2 = this.#children[k];
+          return (typeof c2.#varIndex === "number" ? `(${k})@${c2.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c2.buildRegExpStr();
         });
         if (typeof this.#index === "number") {
           strList.unshift(`#${this.#index}`);
@@ -24157,6 +24348,7 @@ var init_dist6 = __esm({
 // ../integration-github/dist/index.mjs
 var dist_exports4 = {};
 __export(dist_exports4, {
+  ConsolePipelineLogger: () => ConsolePipelineLogger,
   GitHubAuthError: () => GitHubAuthError,
   GitHubClient: () => GitHubClient,
   GitHubError: () => GitHubError,
@@ -24171,7 +24363,7 @@ __export(dist_exports4, {
   parseIssuePayload: () => parseIssuePayload,
   verifyWebhookSignature: () => verifyWebhookSignature
 });
-function formatDuration(ms) {
+function formatDuration2(ms) {
   if (ms < 1e3) return `${ms}ms`;
   const seconds = ms / 1e3;
   if (seconds < 60) return `${seconds.toFixed(1)}s`;
@@ -24192,7 +24384,7 @@ function statusIcon(status) {
   }
 }
 function buildStartComment(payload, enabledStages) {
-  const stageFlow = enabledStages.map((s) => STAGE_LABELS[s]).join(" \u2192 ");
+  const stageFlow = enabledStages.map((s) => STAGE_LABELS2[s]).join(" \u2192 ");
   return [
     `> **Moxxy** is working on this issue`,
     "",
@@ -24210,16 +24402,16 @@ function buildSuccessComment(run2, _payload) {
   lines.push(`> **Moxxy** has completed this issue`);
   lines.push("");
   if (run2.classification) {
-    const c = run2.classification;
+    const c2 = run2.classification;
     lines.push("| | |");
     lines.push("|---|---|");
-    lines.push(`| **Type** | ${c.type} |`);
-    lines.push(`| **Priority** | ${c.priority} |`);
-    lines.push(`| **Complexity** | ${c.complexity} |`);
-    lines.push(`| **Confidence** | ${(c.confidence * 100).toFixed(0)}% |`);
+    lines.push(`| **Type** | ${c2.type} |`);
+    lines.push(`| **Priority** | ${c2.priority} |`);
+    lines.push(`| **Complexity** | ${c2.complexity} |`);
+    lines.push(`| **Confidence** | ${(c2.confidence * 100).toFixed(0)}% |`);
     lines.push("");
-    if (c.reasoning) {
-      lines.push(`> ${c.reasoning}`);
+    if (c2.reasoning) {
+      lines.push(`> ${c2.reasoning}`);
       lines.push("");
     }
   }
@@ -24227,8 +24419,8 @@ function buildSuccessComment(run2, _payload) {
   lines.push("|-------|--------|----------|");
   for (const stage of run2.stages) {
     const icon = statusIcon(stage.status);
-    const duration = stage.duration_ms != null ? formatDuration(stage.duration_ms) : "\u2014";
-    lines.push(`| ${STAGE_LABELS[stage.stage]} | ${icon} ${stage.status} | ${duration} |`);
+    const duration = stage.duration_ms != null ? formatDuration2(stage.duration_ms) : "\u2014";
+    lines.push(`| ${STAGE_LABELS2[stage.stage]} | ${icon} ${stage.status} | ${duration} |`);
   }
   lines.push("");
   if (run2.prNumber) {
@@ -24247,8 +24439,8 @@ function buildFailureComment(run2, error2) {
     lines.push("|-------|--------|----------|");
     for (const stage of run2.stages) {
       const icon = statusIcon(stage.status);
-      const duration = stage.duration_ms != null ? formatDuration(stage.duration_ms) : "\u2014";
-      lines.push(`| ${STAGE_LABELS[stage.stage]} | ${icon} ${stage.status} | ${duration} |`);
+      const duration = stage.duration_ms != null ? formatDuration2(stage.duration_ms) : "\u2014";
+      lines.push(`| ${STAGE_LABELS2[stage.stage]} | ${icon} ${stage.status} | ${duration} |`);
     }
     lines.push("");
   }
@@ -24260,6 +24452,21 @@ function buildFailureComment(run2, error2) {
   lines.push("<sub>Automated by Moxxy</sub>");
   return lines.join("\n");
 }
+function formatTime7() {
+  return (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+}
+function log3(level, issueKey, message) {
+  const time = `${c.dim}${formatTime7()}${c.reset}`;
+  const tag = `${c.magenta}[Pipeline]${c.reset}`;
+  const issue = `${c.cyan}${issueKey}${c.reset}`;
+  const levels = {
+    info: `${c.blue}INFO ${c.reset}`,
+    ok: `${c.green}OK   ${c.reset}`,
+    fail: `${c.red}FAIL ${c.reset}`,
+    skip: `${c.gray}SKIP ${c.reset}`
+  };
+  console.log(`${time} ${levels[level]}${tag} ${issue} ${message}`);
+}
 async function implementIssue(supervisor, agentId, payload, workflow) {
   const instruction = {
     prompt: `Execute this workflow for issue #${payload.issueNumber}: ${payload.title}
@@ -24488,7 +24695,7 @@ Automated by Moxxy.`,
     base: defaultBranch
   });
 }
-var import_crypto4, GitHubError, GitHubAuthError, GitHubWebhookError, GitHubPipelineError, GitHubClient, STAGE_LABELS, DEFAULT_CLASSIFICATION, DEFAULT_RESEARCH, DEFAULT_INSPECT, IssuePipeline, WebhookServer, GitHubIntegration;
+var import_crypto4, GitHubError, GitHubAuthError, GitHubWebhookError, GitHubPipelineError, GitHubClient, STAGE_LABELS2, c, ConsolePipelineLogger, DEFAULT_CLASSIFICATION, DEFAULT_RESEARCH, DEFAULT_INSPECT, IssuePipeline, WebhookServer, GitHubIntegration;
 var init_dist7 = __esm({
   "../integration-github/dist/index.mjs"() {
     "use strict";
@@ -24591,13 +24798,53 @@ var init_dist7 = __esm({
         return data;
       }
     };
-    STAGE_LABELS = {
+    STAGE_LABELS2 = {
       triage: "Triage",
       research: "Research",
       inspect: "Inspect",
       plan: "Plan",
       implement: "Implement"
     };
+    c = {
+      reset: "\x1B[0m",
+      bold: "\x1B[1m",
+      dim: "\x1B[2m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      magenta: "\x1B[35m",
+      cyan: "\x1B[36m",
+      gray: "\x1B[90m"
+    };
+    ConsolePipelineLogger = class {
+      pipelineStart(issueKey, title, stages, skipped) {
+        log3("info", issueKey, `${c.bold}Pipeline started${c.reset} \u2014 ${title}`);
+        const skipNote = skipped.length ? ` ${c.dim}(skipped: ${skipped.join(", ")})${c.reset}` : "";
+        log3("info", issueKey, `Stages: ${stages.join(" \u2192 ")}${skipNote}`);
+      }
+      stageStart(issueKey, stage) {
+        log3("info", issueKey, `Stage ${c.bold}${stage}${c.reset} starting...`);
+      }
+      stageSkip(issueKey, stage) {
+        log3("skip", issueKey, `Stage ${stage} skipped \u2014 using defaults`);
+      }
+      stageComplete(issueKey, stage, durationMs) {
+        log3("ok", issueKey, `Stage ${c.bold}${stage}${c.reset} completed in ${formatDuration2(durationMs)}`);
+      }
+      stageFail(issueKey, stage, error2, durationMs) {
+        log3("fail", issueKey, `Stage ${c.bold}${stage}${c.reset} failed in ${formatDuration2(durationMs)} \u2014 ${error2}`);
+      }
+      info(issueKey, message) {
+        log3("info", issueKey, message);
+      }
+      pipelineComplete(issueKey, durationMs, prNumber, branch) {
+        log3("ok", issueKey, `${c.bold}Pipeline completed${c.reset} in ${formatDuration2(durationMs)} \u2014 PR #${prNumber} on branch ${branch}`);
+      }
+      pipelineFail(issueKey, durationMs, error2) {
+        log3("fail", issueKey, `${c.bold}Pipeline failed${c.reset} after ${formatDuration2(durationMs)} \u2014 ${error2}`);
+      }
+    };
     DEFAULT_CLASSIFICATION = {
       type: "feature",
       priority: "medium",
@@ -24618,7 +24865,7 @@ var init_dist7 = __esm({
       estimatedChanges: []
     };
     IssuePipeline = class {
-      constructor(supervisor, moltAgentId, github, enabledStages) {
+      constructor(supervisor, moltAgentId, github, enabledStages, logger) {
         this.supervisor = supervisor;
         this.moltAgentId = moltAgentId;
         this.github = github;
@@ -24626,8 +24873,10 @@ var init_dist7 = __esm({
         if (!stages.includes("plan")) stages.push("plan");
         if (!stages.includes("implement")) stages.push("implement");
         this.enabledStages = new Set(stages);
+        this.logger = logger ?? new ConsolePipelineLogger();
       }
       enabledStages;
+      logger;
       async run(payload) {
         const pipelineRun = {
           id: `pipeline-${Date.now()}`,
@@ -24638,8 +24887,12 @@ var init_dist7 = __esm({
           createdAt: Date.now(),
           updatedAt: Date.now()
         };
+        const issueKey = `#${payload.issueNumber}`;
         const activeStages = PIPELINE_STAGES.filter((s) => this.enabledStages.has(s));
+        const skippedStages = PIPELINE_STAGES.filter((s) => !this.enabledStages.has(s));
+        this.logger.pipelineStart(issueKey, payload.title, activeStages, skippedStages);
         let commentId;
+        const pipelineStart = Date.now();
         try {
           commentId = await this.github.commentOnIssue(
             payload.repo.owner,
@@ -24649,60 +24902,75 @@ var init_dist7 = __esm({
           );
           let classification;
           if (this.enabledStages.has("triage")) {
+            this.logger.stageStart(issueKey, "triage");
             const triageResult = await this.runStage(
               "triage",
               () => triageIssue(this.supervisor, this.moltAgentId, payload)
             );
             pipelineRun.stages.push(triageResult);
+            this.logStageResult(issueKey, triageResult);
             if (triageResult.status === "failed")
               throw new Error(`Triage failed: ${triageResult.error}`);
             classification = triageResult.output;
+            this.logger.info(issueKey, `Classification: ${classification.type} / ${classification.priority} priority / ${classification.complexity} complexity (confidence: ${classification.confidence})`);
           } else {
+            this.logger.stageSkip(issueKey, "triage");
             classification = DEFAULT_CLASSIFICATION;
           }
           pipelineRun.classification = classification;
           let researchOutput;
           if (this.enabledStages.has("research")) {
+            this.logger.stageStart(issueKey, "research");
             const researchResult = await this.runStage(
               "research",
               () => researchIssue(this.supervisor, this.moltAgentId, payload, classification)
             );
             pipelineRun.stages.push(researchResult);
+            this.logStageResult(issueKey, researchResult);
             if (researchResult.status === "failed")
               throw new Error(`Research failed: ${researchResult.error}`);
             researchOutput = researchResult.output;
           } else {
+            this.logger.stageSkip(issueKey, "research");
             researchOutput = DEFAULT_RESEARCH;
           }
           let inspectOutput;
           if (this.enabledStages.has("inspect")) {
+            this.logger.stageStart(issueKey, "inspect");
             const inspectResult = await this.runStage(
               "inspect",
               () => inspectIssue(this.supervisor, this.moltAgentId, payload, researchOutput)
             );
             pipelineRun.stages.push(inspectResult);
+            this.logStageResult(issueKey, inspectResult);
             if (inspectResult.status === "failed")
               throw new Error(`Inspect failed: ${inspectResult.error}`);
             inspectOutput = inspectResult.output;
           } else {
+            this.logger.stageSkip(issueKey, "inspect");
             inspectOutput = DEFAULT_INSPECT;
           }
+          this.logger.stageStart(issueKey, "plan");
           const planResult = await this.runStage(
             "plan",
             () => planIssue(this.supervisor, this.moltAgentId, payload, inspectOutput)
           );
           pipelineRun.stages.push(planResult);
+          this.logStageResult(issueKey, planResult);
           if (planResult.status === "failed") throw new Error(`Plan failed: ${planResult.error}`);
           const branchName = `moxxy/issue-${payload.issueNumber}`;
           const workflow = buildWorkflow(payload, planResult.output, branchName);
+          this.logger.stageStart(issueKey, "implement");
           const implementResult = await this.runStage(
             "implement",
             () => implementIssue(this.supervisor, this.moltAgentId, payload, workflow)
           );
           pipelineRun.stages.push(implementResult);
+          this.logStageResult(issueKey, implementResult);
           if (implementResult.status === "failed")
             throw new Error(`Implement failed: ${implementResult.error}`);
           pipelineRun.branchName = branchName;
+          this.logger.info(issueKey, "Creating pull request...");
           const classificationNote = pipelineRun.classification ? `
 
 **Classification:** ${pipelineRun.classification.type} (${pipelineRun.classification.priority} priority, ${pipelineRun.classification.complexity} complexity)` : "";
@@ -24717,6 +24985,7 @@ Automated implementation by Moxxy.${classificationNote}`,
           pipelineRun.prNumber = prNumber;
           pipelineRun.status = "completed";
           pipelineRun.updatedAt = Date.now();
+          this.logger.pipelineComplete(issueKey, Date.now() - pipelineStart, prNumber, branchName);
           if (commentId) {
             await this.github.updateComment(
               payload.repo.owner,
@@ -24729,6 +24998,8 @@ Automated implementation by Moxxy.${classificationNote}`,
         } catch (error2) {
           pipelineRun.status = "failed";
           pipelineRun.updatedAt = Date.now();
+          const errMsg = error2 instanceof Error ? error2.message : String(error2);
+          this.logger.pipelineFail(issueKey, Date.now() - pipelineStart, errMsg);
           if (commentId) {
             await this.github.updateComment(
               payload.repo.owner,
@@ -24741,6 +25012,13 @@ Automated implementation by Moxxy.${classificationNote}`,
           return pipelineRun;
         }
       }
+      logStageResult(issueKey, result) {
+        if (result.status === "completed") {
+          this.logger.stageComplete(issueKey, result.stage, result.duration_ms ?? 0);
+        } else {
+          this.logger.stageFail(issueKey, result.stage, result.error ?? "Unknown error", result.duration_ms ?? 0);
+        }
+      }
       async runStage(stage, fn) {
         const start = Date.now();
         try {
@@ -24771,23 +25049,23 @@ Automated implementation by Moxxy.${classificationNote}`,
         this.setupRoutes();
       }
       setupRoutes() {
-        this.app.get("/health", (c) => {
-          return c.json({ status: "ok", timestamp: Date.now() });
+        this.app.get("/health", (c2) => {
+          return c2.json({ status: "ok", timestamp: Date.now() });
         });
-        this.app.post(this.config.path, async (c) => {
+        this.app.post(this.config.path, async (c2) => {
           try {
-            const rawBody = await c.req.text();
+            const rawBody = await c2.req.text();
             if (this.config.secret) {
-              const signature = c.req.header("x-hub-signature-256") || "";
+              const signature = c2.req.header("x-hub-signature-256") || "";
               if (!signature) {
-                return c.json({ error: "Missing signature" }, 401);
+                return c2.json({ error: "Missing signature" }, 401);
               }
               if (!verifyWebhookSignature(rawBody, signature, this.config.secret)) {
-                return c.json({ error: "Invalid signature" }, 401);
+                return c2.json({ error: "Invalid signature" }, 401);
               }
             }
             const body = JSON.parse(rawBody);
-            const event = c.req.header("x-github-event") || "";
+            const event = c2.req.header("x-github-event") || "";
             if (event === "issues") {
               const payload = parseIssuePayload(body);
               if (payload) {
@@ -24796,7 +25074,7 @@ Automated implementation by Moxxy.${classificationNote}`,
                 });
               }
             }
-            return c.json({ received: true });
+            return c2.json({ received: true });
           } catch (error2) {
             const message = error2 instanceof Error ? error2.message : String(error2);
             throw new GitHubWebhookError(
@@ -24852,7 +25130,8 @@ Automated implementation by Moxxy.${classificationNote}`,
           this.config.supervisor,
           this.config.moltAgentId,
           this.client,
-          this.config.enabledStages
+          this.config.enabledStages,
+          this.config.pipelineLogger
         );
         await this.client.verifyAuth();
         this.webhookServer = new WebhookServer({
@@ -25005,7 +25284,8 @@ function registerStartCommand(program) {
           sdk,
           supervisor,
           moltAgentId: agentId || "",
-          enabledStages: config.pipeline?.enabledStages
+          enabledStages: config.pipeline?.enabledStages,
+          pipelineLogger: new SpinnerPipelineLogger()
         });
         webhookSpinner.succeed(
           `Webhook server listening on ${import_chalk.default.cyan(`${webhookConfig.host}:${webhookConfig.port}${webhookConfig.path}`)}`
@@ -25050,6 +25330,7 @@ var init_start = __esm({
     "use strict";
     init_config_manager();
     init_logger();
+    init_pipeline_logger();
     SDK_NAMES2 = {
       molt: "Molt Gateway",
       claude: "Claude CLI"
@@ -25145,7 +25426,7 @@ __export(cli_exports, {
 });
 function createProgram() {
   const program = new import_commander.Command();
-  program.name("moxxy").description("Moxxy - Agent orchestration platform").version("0.0.7");
+  program.name("moxxy").description("Moxxy - Agent orchestration platform").version("0.0.9");
   registerStartCommand(program);
   registerRepoCommand(program);
   registerConfigCommand(program);