@moxxy/cli 0.0.3 → 0.0.4

package/dist/index.js

@@ -34,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../types/dist/index.mjs
-var import_zod, import_zod2, import_zod3, import_zod4, import_zod5, import_zod6, import_zod7, import_zod8, import_zod9, import_zod10, import_zod11, uuidSchema, timestampSchema, paginationSchema, activityTypeSchema, taskActivitySchema, createActivitySchema, agentStatusSchema, agentTypeSchema, agentCapabilitySchema, agentIdentitySchema, agentModelConfigSchema, agentSchema, createAgentSchema, updateAgentSchema, taskFiltersSchema, INTEGRATION_TYPES, NOTIFICATION_EVENTS, createIntegrationSchema, updateIntegrationSchema, projectStatusSchema, workflowModeSchema, validationSettingsSchema, workflowSettingsSchema, prdStatusSchema, prdTemplateSchema, prdTaskSchema, projectSchema, generatePRDInputSchema, importPRDTasksInputSchema, updatePRDInputSchema, createProjectSchema, updateProjectSchema, taskStatusSchema, taskTypeSchema, taskPrioritySchema, agentNoteTypeSchema, agentNoteSchema, taskSchema, createTaskSchema, updateTaskSchema, clientEventTypeSchema, serverEventTypeSchema, gatewayConfigSchema, githubAuthConfigSchema, webhookServerConfigSchema, watchedRepoSchema, agentRunConfigSchema, sdkProviderSchema, claudeConfigSchema, moxxyConfigSchema, agentCommandResultSchema, argDefSchema, optionDefSchema, agentCLICommandDefSchema, workflowStepSchema, workflowSchema, workflowStepResultSchema, workflowResultSchema, githubIssuePayloadSchema, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_COMPLEXITIES, issueClassificationSchema, PIPELINE_STAGES, PIPELINE_STATUSES, pipelineStageResultSchema, pipelineRunSchema;
+var import_zod, import_zod2, import_zod3, import_zod4, import_zod5, import_zod6, import_zod7, import_zod8, import_zod9, import_zod10, import_zod11, uuidSchema, timestampSchema, paginationSchema, activityTypeSchema, taskActivitySchema, createActivitySchema, agentStatusSchema, agentTypeSchema, agentCapabilitySchema, agentIdentitySchema, agentModelConfigSchema, agentSchema, createAgentSchema, updateAgentSchema, taskFiltersSchema, INTEGRATION_TYPES, NOTIFICATION_EVENTS, createIntegrationSchema, updateIntegrationSchema, projectStatusSchema, workflowModeSchema, validationSettingsSchema, workflowSettingsSchema, prdStatusSchema, prdTemplateSchema, prdTaskSchema, projectSchema, generatePRDInputSchema, importPRDTasksInputSchema, updatePRDInputSchema, createProjectSchema, updateProjectSchema, taskStatusSchema, taskTypeSchema, taskPrioritySchema, agentNoteTypeSchema, agentNoteSchema, taskSchema, createTaskSchema, updateTaskSchema, clientEventTypeSchema, serverEventTypeSchema, githubIssuePayloadSchema, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_COMPLEXITIES, issueClassificationSchema, PIPELINE_STAGES, PIPELINE_STATUSES, pipelineStageResultSchema, pipelineRunSchema, gatewayConfigSchema, githubAuthConfigSchema, webhookServerConfigSchema, watchedRepoSchema, agentRunConfigSchema, sdkProviderSchema, claudeConfigSchema, pipelineConfigSchema, moxxyConfigSchema, agentCommandResultSchema, argDefSchema, optionDefSchema, agentCLICommandDefSchema, workflowStepSchema, workflowSchema, workflowStepResultSchema, workflowResultSchema;
 var init_dist = __esm({
   "../types/dist/index.mjs"() {
     "use strict";
@@ -390,6 +390,69 @@ var init_dist = __esm({
       "project:prd_status_changed",
       "error"
     ]);
+    githubIssuePayloadSchema = import_zod10.z.object({
+      action: import_zod10.z.string(),
+      issueNumber: import_zod10.z.number().int().positive(),
+      title: import_zod10.z.string(),
+      body: import_zod10.z.string().nullable(),
+      labels: import_zod10.z.array(import_zod10.z.string()),
+      author: import_zod10.z.string(),
+      repo: import_zod10.z.object({
+        owner: import_zod10.z.string(),
+        name: import_zod10.z.string(),
+        fullName: import_zod10.z.string(),
+        defaultBranch: import_zod10.z.string(),
+        cloneUrl: import_zod10.z.string()
+      }),
+      url: import_zod10.z.string().url(),
+      createdAt: import_zod10.z.string()
+    });
+    ISSUE_TYPES = ["feature", "bug", "refactor", "docs", "test", "chore"];
+    ISSUE_PRIORITIES = ["low", "medium", "high", "urgent"];
+    ISSUE_COMPLEXITIES = ["trivial", "small", "medium", "large", "epic"];
+    issueClassificationSchema = import_zod10.z.object({
+      type: import_zod10.z.enum(ISSUE_TYPES),
+      priority: import_zod10.z.enum(ISSUE_PRIORITIES),
+      complexity: import_zod10.z.enum(ISSUE_COMPLEXITIES),
+      confidence: import_zod10.z.number().min(0).max(1),
+      reasoning: import_zod10.z.string()
+    });
+    PIPELINE_STAGES = [
+      "triage",
+      "research",
+      "inspect",
+      "plan",
+      "implement"
+    ];
+    PIPELINE_STATUSES = [
+      "pending",
+      "running",
+      "completed",
+      "failed",
+      "cancelled"
+    ];
+    pipelineStageResultSchema = import_zod10.z.object({
+      stage: import_zod10.z.enum(PIPELINE_STAGES),
+      status: import_zod10.z.enum(PIPELINE_STATUSES),
+      output: import_zod10.z.unknown().optional(),
+      error: import_zod10.z.string().optional(),
+      duration_ms: import_zod10.z.number().optional()
+    });
+    pipelineRunSchema = import_zod10.z.object({
+      id: import_zod10.z.string(),
+      issueNumber: import_zod10.z.number().int().positive(),
+      repo: import_zod10.z.object({
+        owner: import_zod10.z.string(),
+        name: import_zod10.z.string()
+      }),
+      stages: import_zod10.z.array(pipelineStageResultSchema),
+      status: import_zod10.z.enum(PIPELINE_STATUSES),
+      branchName: import_zod10.z.string().optional(),
+      prNumber: import_zod10.z.number().int().positive().optional(),
+      classification: issueClassificationSchema.optional(),
+      createdAt: import_zod10.z.number(),
+      updatedAt: import_zod10.z.number()
+    });
     gatewayConfigSchema = import_zod9.z.object({
       url: import_zod9.z.string().url(),
       authToken: import_zod9.z.string().optional(),
@@ -426,6 +489,9 @@ var init_dist = __esm({
       timeout: import_zod9.z.number().int().positive().default(3e5),
       permissionMode: import_zod9.z.string().default("default")
     });
+    pipelineConfigSchema = import_zod9.z.object({
+      enabledStages: import_zod9.z.array(import_zod9.z.enum(PIPELINE_STAGES)).default(["triage", "research", "inspect", "plan", "implement"])
+    });
     moxxyConfigSchema = import_zod9.z.object({
       version: import_zod9.z.number().int().positive().default(1),
       sdk: sdkProviderSchema,
@@ -434,129 +500,67 @@ var init_dist = __esm({
       webhook: webhookServerConfigSchema.optional(),
       repos: import_zod9.z.array(watchedRepoSchema).default([]),
       agent: agentRunConfigSchema.optional(),
+      pipeline: pipelineConfigSchema.optional(),
       claude: claudeConfigSchema.optional()
     });
-    agentCommandResultSchema = import_zod10.z.object({
-      success: import_zod10.z.boolean(),
-      command: import_zod10.z.string(),
-      data: import_zod10.z.unknown().optional(),
-      error: import_zod10.z.object({
-        code: import_zod10.z.string(),
-        message: import_zod10.z.string(),
-        details: import_zod10.z.string().optional()
+    agentCommandResultSchema = import_zod11.z.object({
+      success: import_zod11.z.boolean(),
+      command: import_zod11.z.string(),
+      data: import_zod11.z.unknown().optional(),
+      error: import_zod11.z.object({
+        code: import_zod11.z.string(),
+        message: import_zod11.z.string(),
+        details: import_zod11.z.string().optional()
       }).optional(),
-      duration_ms: import_zod10.z.number()
+      duration_ms: import_zod11.z.number()
     });
-    argDefSchema = import_zod10.z.object({
-      name: import_zod10.z.string(),
-      description: import_zod10.z.string(),
-      required: import_zod10.z.boolean().default(false),
-      type: import_zod10.z.enum(["string", "number", "boolean"]).default("string")
+    argDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      required: import_zod11.z.boolean().default(false),
+      type: import_zod11.z.enum(["string", "number", "boolean"]).default("string")
     });
-    optionDefSchema = import_zod10.z.object({
-      name: import_zod10.z.string(),
-      short: import_zod10.z.string().optional(),
-      description: import_zod10.z.string(),
-      required: import_zod10.z.boolean().default(false),
-      type: import_zod10.z.enum(["string", "number", "boolean"]).default("string"),
-      defaultValue: import_zod10.z.unknown().optional()
+    optionDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      short: import_zod11.z.string().optional(),
+      description: import_zod11.z.string(),
+      required: import_zod11.z.boolean().default(false),
+      type: import_zod11.z.enum(["string", "number", "boolean"]).default("string"),
+      defaultValue: import_zod11.z.unknown().optional()
     });
-    agentCLICommandDefSchema = import_zod10.z.object({
-      name: import_zod10.z.string(),
-      description: import_zod10.z.string(),
-      args: import_zod10.z.array(argDefSchema),
-      options: import_zod10.z.array(optionDefSchema),
-      examples: import_zod10.z.array(import_zod10.z.string())
+    agentCLICommandDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      args: import_zod11.z.array(argDefSchema),
+      options: import_zod11.z.array(optionDefSchema),
+      examples: import_zod11.z.array(import_zod11.z.string())
     });
-    workflowStepSchema = import_zod10.z.object({
-      id: import_zod10.z.string(),
-      plugin: import_zod10.z.string(),
-      command: import_zod10.z.string(),
-      args: import_zod10.z.record(import_zod10.z.unknown()),
-      description: import_zod10.z.string(),
-      dependsOn: import_zod10.z.array(import_zod10.z.string()).optional(),
-      optional: import_zod10.z.boolean().optional()
+    workflowStepSchema = import_zod11.z.object({
+      id: import_zod11.z.string(),
+      plugin: import_zod11.z.string(),
+      command: import_zod11.z.string(),
+      args: import_zod11.z.record(import_zod11.z.unknown()),
+      description: import_zod11.z.string(),
+      dependsOn: import_zod11.z.array(import_zod11.z.string()).optional(),
+      optional: import_zod11.z.boolean().optional()
     });
-    workflowSchema = import_zod10.z.object({
-      id: import_zod10.z.string(),
-      name: import_zod10.z.string(),
-      description: import_zod10.z.string(),
-      steps: import_zod10.z.array(workflowStepSchema),
-      context: import_zod10.z.record(import_zod10.z.unknown())
+    workflowSchema = import_zod11.z.object({
+      id: import_zod11.z.string(),
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      steps: import_zod11.z.array(workflowStepSchema),
+      context: import_zod11.z.record(import_zod11.z.unknown())
     });
-    workflowStepResultSchema = import_zod10.z.object({
-      stepId: import_zod10.z.string(),
+    workflowStepResultSchema = import_zod11.z.object({
+      stepId: import_zod11.z.string(),
       result: agentCommandResultSchema,
-      skipped: import_zod10.z.boolean().default(false)
+      skipped: import_zod11.z.boolean().default(false)
     });
-    workflowResultSchema = import_zod10.z.object({
-      workflowId: import_zod10.z.string(),
-      success: import_zod10.z.boolean(),
-      stepResults: import_zod10.z.array(workflowStepResultSchema),
-      duration_ms: import_zod10.z.number()
-    });
-    githubIssuePayloadSchema = import_zod11.z.object({
-      action: import_zod11.z.string(),
-      issueNumber: import_zod11.z.number().int().positive(),
-      title: import_zod11.z.string(),
-      body: import_zod11.z.string().nullable(),
-      labels: import_zod11.z.array(import_zod11.z.string()),
-      author: import_zod11.z.string(),
-      repo: import_zod11.z.object({
-        owner: import_zod11.z.string(),
-        name: import_zod11.z.string(),
-        fullName: import_zod11.z.string(),
-        defaultBranch: import_zod11.z.string(),
-        cloneUrl: import_zod11.z.string()
-      }),
-      url: import_zod11.z.string().url(),
-      createdAt: import_zod11.z.string()
-    });
-    ISSUE_TYPES = ["feature", "bug", "refactor", "docs", "test", "chore"];
-    ISSUE_PRIORITIES = ["low", "medium", "high", "urgent"];
-    ISSUE_COMPLEXITIES = ["trivial", "small", "medium", "large", "epic"];
-    issueClassificationSchema = import_zod11.z.object({
-      type: import_zod11.z.enum(ISSUE_TYPES),
-      priority: import_zod11.z.enum(ISSUE_PRIORITIES),
-      complexity: import_zod11.z.enum(ISSUE_COMPLEXITIES),
-      confidence: import_zod11.z.number().min(0).max(1),
-      reasoning: import_zod11.z.string()
-    });
-    PIPELINE_STAGES = [
-      "triage",
-      "research",
-      "inspect",
-      "plan",
-      "implement"
-    ];
-    PIPELINE_STATUSES = [
-      "pending",
-      "running",
-      "completed",
-      "failed",
-      "cancelled"
-    ];
-    pipelineStageResultSchema = import_zod11.z.object({
-      stage: import_zod11.z.enum(PIPELINE_STAGES),
-      status: import_zod11.z.enum(PIPELINE_STATUSES),
-      output: import_zod11.z.unknown().optional(),
-      error: import_zod11.z.string().optional(),
-      duration_ms: import_zod11.z.number().optional()
-    });
-    pipelineRunSchema = import_zod11.z.object({
-      id: import_zod11.z.string(),
-      issueNumber: import_zod11.z.number().int().positive(),
-      repo: import_zod11.z.object({
-        owner: import_zod11.z.string(),
-        name: import_zod11.z.string()
-      }),
-      stages: import_zod11.z.array(pipelineStageResultSchema),
-      status: import_zod11.z.enum(PIPELINE_STATUSES),
-      branchName: import_zod11.z.string().optional(),
-      prNumber: import_zod11.z.number().int().positive().optional(),
-      classification: issueClassificationSchema.optional(),
-      createdAt: import_zod11.z.number(),
-      updatedAt: import_zod11.z.number()
+    workflowResultSchema = import_zod11.z.object({
+      workflowId: import_zod11.z.string(),
+      success: import_zod11.z.boolean(),
+      stepResults: import_zod11.z.array(workflowStepResultSchema),
+      duration_ms: import_zod11.z.number()
     });
   }
 });
@@ -23354,69 +23358,114 @@ __export(dist_exports4, {
   parseIssuePayload: () => parseIssuePayload,
   verifyWebhookSignature: () => verifyWebhookSignature
 });
-function verifyWebhookSignature(payload, signature, secret) {
-  const expected = "sha256=" + (0, import_crypto4.createHmac)("sha256", secret).update(payload).digest("hex");
-  if (expected.length !== signature.length) return false;
-  return (0, import_crypto4.timingSafeEqual)(Buffer.from(expected), Buffer.from(signature));
+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 remaining = Math.round(seconds % 60);
+  return remaining > 0 ? `${minutes}m ${remaining}s` : `${minutes}m`;
 }
-function parseIssuePayload(body) {
-  const issue = body.issue;
-  if (!issue) return null;
-  return {
-    action: body.action,
-    issueNumber: issue.number,
-    title: issue.title,
-    body: issue.body ?? null,
-    labels: (issue.labels || []).map((l) => l.name),
-    author: issue.user?.login || "unknown",
-    repo: {
-      owner: body.repository.owner.login,
-      name: body.repository.name,
-      fullName: body.repository.full_name,
-      defaultBranch: body.repository.default_branch,
-      cloneUrl: body.repository.clone_url
-    },
-    url: issue.html_url,
-    createdAt: issue.created_at
-  };
+function statusIcon(status) {
+  switch (status) {
+    case "completed":
+      return "\u2705";
+    case "failed":
+      return "\u274C";
+    case "running":
+      return "\u23F3";
+    default:
+      return "\u2B1C";
+  }
 }
-async function triageIssue(supervisor, agentId, payload) {
-  const instruction = {
-    prompt: `Classify this GitHub issue. Return ONLY a JSON object.
-
-Issue #${payload.issueNumber}: ${payload.title}
-${payload.body || "No description provided."}
-Labels: ${payload.labels.join(", ") || "none"}
-
-Return JSON: {"type": "feature|bug|refactor|docs|test|chore", "priority": "low|medium|high|urgent", "complexity": "trivial|small|medium|large|epic", "confidence": 0.0-1.0, "reasoning": "..."}`,
-    metadata: { stage: "triage", issueNumber: payload.issueNumber }
-  };
-  const result = await supervisor.sendInstruction(agentId, instruction);
-  const jsonMatch = result.response.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON found in triage response");
-  return JSON.parse(jsonMatch[0]);
+function buildStartComment(payload, enabledStages) {
+  const stageFlow = enabledStages.map((s) => STAGE_LABELS[s]).join(" \u2192 ");
+  return [
+    `> **Moxxy** is working on this issue`,
+    "",
+    "| | |",
+    "|---|---|",
+    `| **Issue** | #${payload.issueNumber} \u2014 ${payload.title} |`,
+    `| **Branch** | \`moxxy/issue-${payload.issueNumber}\` |`,
+    `| **Stages** | ${stageFlow} |`,
+    "",
+    "_This comment will be updated when the pipeline completes._"
+  ].join("\n");
 }
-async function researchIssue(supervisor, agentId, payload, classification) {
+function buildSuccessComment(run2, _payload) {
+  const lines = [];
+  lines.push(`> **Moxxy** has completed this issue`);
+  lines.push("");
+  if (run2.classification) {
+    const c = 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("");
+    if (c.reasoning) {
+      lines.push(`> ${c.reasoning}`);
+      lines.push("");
+    }
+  }
+  lines.push("| Stage | Status | Duration |");
+  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} |`);
+  }
+  lines.push("");
+  if (run2.prNumber) {
+    lines.push(`**Result:** PR #${run2.prNumber} created on branch \`${run2.branchName}\``);
+  }
+  lines.push("");
+  lines.push("<sub>Automated by Moxxy</sub>");
+  return lines.join("\n");
+}
+function buildFailureComment(run2, error2) {
+  const lines = [];
+  lines.push(`> **Moxxy** pipeline failed`);
+  lines.push("");
+  if (run2.stages.length > 0) {
+    lines.push("| Stage | Status | Duration |");
+    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} |`);
+    }
+    lines.push("");
+  }
+  const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+  lines.push("```");
+  lines.push(errorMessage);
+  lines.push("```");
+  lines.push("");
+  lines.push("<sub>Automated by Moxxy</sub>");
+  return lines.join("\n");
+}
+async function implementIssue(supervisor, agentId, payload, workflow) {
   const instruction = {
-    prompt: `Research this ${classification.type} issue in the codebase.
+    prompt: `Execute this workflow for issue #${payload.issueNumber}: ${payload.title}
 
-Issue #${payload.issueNumber}: ${payload.title}
-${payload.body || ""}
-Repository: ${payload.repo.fullName}
-Classification: ${JSON.stringify(classification)}
+Workflow:
+${JSON.stringify(workflow, null, 2)}
 
-Analyze the codebase and identify:
-1. Relevant files and code areas
-2. Dependencies and related modules
-3. Potential impact areas
+Execute each step using the moxxy-agent CLI tool. For each step, run:
+moxxy-agent <plugin> <command> <args>
 
-Return JSON: {"relevantFiles": [...], "relatedModules": [...], "potentialImpact": "...", "techStack": [...]}`,
-    metadata: { stage: "research", issueNumber: payload.issueNumber }
+Handle any errors by adapting. Report the results of each step.`,
+    metadata: {
+      stage: "implement",
+      issueNumber: payload.issueNumber,
+      workflowId: workflow.id
+    }
   };
   const result = await supervisor.sendInstruction(agentId, instruction);
-  const jsonMatch = result.response.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON found in research response");
-  return JSON.parse(jsonMatch[0]);
+  return { response: result.response, sessionKey: result.sessionKey };
 }
 async function inspectIssue(supervisor, agentId, payload, research) {
   const instruction = {
@@ -23458,25 +23507,43 @@ Return JSON: {"steps": [{"action": "create|modify|delete", "path": "...", "descr
   if (!jsonMatch) throw new Error("No JSON found in plan response");
   return JSON.parse(jsonMatch[0]);
 }
-async function implementIssue(supervisor, agentId, payload, workflow) {
+async function researchIssue(supervisor, agentId, payload, classification) {
   const instruction = {
-    prompt: `Execute this workflow for issue #${payload.issueNumber}: ${payload.title}
+    prompt: `Research this ${classification.type} issue in the codebase.
 
-Workflow:
-${JSON.stringify(workflow, null, 2)}
+Issue #${payload.issueNumber}: ${payload.title}
+${payload.body || ""}
+Repository: ${payload.repo.fullName}
+Classification: ${JSON.stringify(classification)}
 
-Execute each step using the moxxy-agent CLI tool. For each step, run:
-moxxy-agent <plugin> <command> <args>
+Analyze the codebase and identify:
+1. Relevant files and code areas
+2. Dependencies and related modules
+3. Potential impact areas
 
-Handle any errors by adapting. Report the results of each step.`,
-    metadata: {
-      stage: "implement",
-      issueNumber: payload.issueNumber,
-      workflowId: workflow.id
-    }
+Return JSON: {"relevantFiles": [...], "relatedModules": [...], "potentialImpact": "...", "techStack": [...]}`,
+    metadata: { stage: "research", issueNumber: payload.issueNumber }
   };
   const result = await supervisor.sendInstruction(agentId, instruction);
-  return { response: result.response, sessionKey: result.sessionKey };
+  const jsonMatch = result.response.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) throw new Error("No JSON found in research response");
+  return JSON.parse(jsonMatch[0]);
+}
+async function triageIssue(supervisor, agentId, payload) {
+  const instruction = {
+    prompt: `Classify this GitHub issue. Return ONLY a JSON object.
+
+Issue #${payload.issueNumber}: ${payload.title}
+${payload.body || "No description provided."}
+Labels: ${payload.labels.join(", ") || "none"}
+
+Return JSON: {"type": "feature|bug|refactor|docs|test|chore", "priority": "low|medium|high|urgent", "complexity": "trivial|small|medium|large|epic", "confidence": 0.0-1.0, "reasoning": "..."}`,
+    metadata: { stage: "triage", issueNumber: payload.issueNumber }
+  };
+  const result = await supervisor.sendInstruction(agentId, instruction);
+  const jsonMatch = result.response.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) throw new Error("No JSON found in triage response");
+  return JSON.parse(jsonMatch[0]);
 }
 function buildWorkflow(payload, plan, branchName) {
   const steps = [];
@@ -23540,6 +23607,32 @@ function buildWorkflow(payload, plan, branchName) {
     }
   };
 }
+function verifyWebhookSignature(payload, signature, secret) {
+  const expected = "sha256=" + (0, import_crypto4.createHmac)("sha256", secret).update(payload).digest("hex");
+  if (expected.length !== signature.length) return false;
+  return (0, import_crypto4.timingSafeEqual)(Buffer.from(expected), Buffer.from(signature));
+}
+function parseIssuePayload(body) {
+  const issue = body.issue;
+  if (!issue) return null;
+  return {
+    action: body.action,
+    issueNumber: issue.number,
+    title: issue.title,
+    body: issue.body ?? null,
+    labels: (issue.labels || []).map((l) => l.name),
+    author: issue.user?.login || "unknown",
+    repo: {
+      owner: body.repository.owner.login,
+      name: body.repository.name,
+      fullName: body.repository.full_name,
+      defaultBranch: body.repository.default_branch,
+      cloneUrl: body.repository.clone_url
+    },
+    url: issue.html_url,
+    createdAt: issue.created_at
+  };
+}
 async function createBranchFromDefault(client, owner, repo, branchName, defaultBranch) {
   await client.createBranch(owner, repo, branchName, defaultBranch);
 }
@@ -23553,12 +23646,13 @@ Automated by Moxxy.`,
     base: defaultBranch
   });
 }
-var import_crypto4, GitHubError, GitHubAuthError, GitHubWebhookError, GitHubPipelineError, GitHubClient, WebhookServer, IssuePipeline, GitHubIntegration;
+var import_crypto4, GitHubError, GitHubAuthError, GitHubWebhookError, GitHubPipelineError, GitHubClient, STAGE_LABELS, DEFAULT_CLASSIFICATION, DEFAULT_RESEARCH, DEFAULT_INSPECT, IssuePipeline, WebhookServer, GitHubIntegration;
 var init_dist7 = __esm({
   "../integration-github/dist/index.mjs"() {
     "use strict";
     init_dist4();
     init_dist_src5();
+    init_dist();
     init_dist5();
     init_dist6();
     import_crypto4 = require("crypto");
@@ -23646,86 +23740,43 @@ var init_dist7 = __esm({
         return data;
       }
     };
-    WebhookServer = class {
-      server = null;
-      app;
-      config;
-      constructor(config) {
-        this.config = config;
-        this.app = new Hono2();
-        this.setupRoutes();
-      }
-      setupRoutes() {
-        this.app.get("/health", (c) => {
-          return c.json({ status: "ok", timestamp: Date.now() });
-        });
-        this.app.post(this.config.path, async (c) => {
-          try {
-            const rawBody = await c.req.text();
-            if (this.config.secret) {
-              const signature = c.req.header("x-hub-signature-256") || "";
-              if (!signature) {
-                return c.json({ error: "Missing signature" }, 401);
-              }
-              if (!verifyWebhookSignature(rawBody, signature, this.config.secret)) {
-                return c.json({ error: "Invalid signature" }, 401);
-              }
-            }
-            const body = JSON.parse(rawBody);
-            const event = c.req.header("x-github-event") || "";
-            if (event === "issues") {
-              const payload = parseIssuePayload(body);
-              if (payload) {
-                this.config.onIssue(payload).catch((err) => {
-                  console.error("Error processing issue webhook:", err);
-                });
-              }
-            }
-            return c.json({ received: true });
-          } catch (error2) {
-            const message = error2 instanceof Error ? error2.message : String(error2);
-            throw new GitHubWebhookError(
-              `Failed to process webhook: ${message}`,
-              error2 instanceof Error ? error2 : void 0
-            );
-          }
-        });
-      }
-      async start() {
-        return new Promise((resolve) => {
-          this.server = serve(
-            {
-              fetch: this.app.fetch,
-              port: this.config.port,
-              hostname: this.config.host
-            },
-            () => {
-              resolve();
-            }
-          );
-        });
-      }
-      async stop() {
-        if (this.server) {
-          await new Promise((resolve, reject) => {
-            this.server.close((err) => {
-              if (err) {
-                reject(err);
-              } else {
-                resolve();
-              }
-            });
-          });
-          this.server = null;
-        }
-      }
+    STAGE_LABELS = {
+      triage: "Triage",
+      research: "Research",
+      inspect: "Inspect",
+      plan: "Plan",
+      implement: "Implement"
+    };
+    DEFAULT_CLASSIFICATION = {
+      type: "feature",
+      priority: "medium",
+      complexity: "medium",
+      confidence: 0.5,
+      reasoning: "Auto-classified"
+    };
+    DEFAULT_RESEARCH = {
+      relevantFiles: [],
+      relatedModules: [],
+      potentialImpact: "Unknown",
+      techStack: []
+    };
+    DEFAULT_INSPECT = {
+      findings: [],
+      rootCause: "Not inspected",
+      suggestedApproach: "",
+      estimatedChanges: []
     };
     IssuePipeline = class {
-      constructor(supervisor, moltAgentId, github) {
+      constructor(supervisor, moltAgentId, github, enabledStages) {
         this.supervisor = supervisor;
         this.moltAgentId = moltAgentId;
         this.github = github;
+        const stages = enabledStages ?? [...PIPELINE_STAGES];
+        if (!stages.includes("plan")) stages.push("plan");
+        if (!stages.includes("implement")) stages.push("implement");
+        this.enabledStages = new Set(stages);
       }
+      enabledStages;
       async run(payload) {
         const pipelineRun = {
           id: `pipeline-${Date.now()}`,
@@ -23736,63 +23787,62 @@ var init_dist7 = __esm({
           createdAt: Date.now(),
           updatedAt: Date.now()
         };
+        const activeStages = PIPELINE_STAGES.filter((s) => this.enabledStages.has(s));
         try {
           await this.github.commentOnIssue(
             payload.repo.owner,
             payload.repo.name,
             payload.issueNumber,
-            "\u{1F916} Moxxy is analyzing this issue..."
-          );
-          const triageResult = await this.runStage(
-            "triage",
-            () => triageIssue(this.supervisor, this.moltAgentId, payload)
+            buildStartComment(payload, activeStages)
           );
-          pipelineRun.stages.push(triageResult);
-          if (triageResult.status === "failed")
-            throw new Error(`Triage failed: ${triageResult.error}`);
-          pipelineRun.classification = triageResult.output;
-          const researchResult = await this.runStage(
-            "research",
-            () => researchIssue(
-              this.supervisor,
-              this.moltAgentId,
-              payload,
-              pipelineRun.classification
-            )
-          );
-          pipelineRun.stages.push(researchResult);
-          if (researchResult.status === "failed")
-            throw new Error(`Research failed: ${researchResult.error}`);
-          const inspectResult = await this.runStage(
-            "inspect",
-            () => inspectIssue(
-              this.supervisor,
-              this.moltAgentId,
-              payload,
-              researchResult.output
-            )
-          );
-          pipelineRun.stages.push(inspectResult);
-          if (inspectResult.status === "failed")
-            throw new Error(`Inspect failed: ${inspectResult.error}`);
+          let classification;
+          if (this.enabledStages.has("triage")) {
+            const triageResult = await this.runStage(
+              "triage",
+              () => triageIssue(this.supervisor, this.moltAgentId, payload)
+            );
+            pipelineRun.stages.push(triageResult);
+            if (triageResult.status === "failed")
+              throw new Error(`Triage failed: ${triageResult.error}`);
+            classification = triageResult.output;
+          } else {
+            classification = DEFAULT_CLASSIFICATION;
+          }
+          pipelineRun.classification = classification;
+          let researchOutput;
+          if (this.enabledStages.has("research")) {
+            const researchResult = await this.runStage(
+              "research",
+              () => researchIssue(this.supervisor, this.moltAgentId, payload, classification)
+            );
+            pipelineRun.stages.push(researchResult);
+            if (researchResult.status === "failed")
+              throw new Error(`Research failed: ${researchResult.error}`);
+            researchOutput = researchResult.output;
+          } else {
+            researchOutput = DEFAULT_RESEARCH;
+          }
+          let inspectOutput;
+          if (this.enabledStages.has("inspect")) {
+            const inspectResult = await this.runStage(
+              "inspect",
+              () => inspectIssue(this.supervisor, this.moltAgentId, payload, researchOutput)
+            );
+            pipelineRun.stages.push(inspectResult);
+            if (inspectResult.status === "failed")
+              throw new Error(`Inspect failed: ${inspectResult.error}`);
+            inspectOutput = inspectResult.output;
+          } else {
+            inspectOutput = DEFAULT_INSPECT;
+          }
           const planResult = await this.runStage(
             "plan",
-            () => planIssue(
-              this.supervisor,
-              this.moltAgentId,
-              payload,
-              inspectResult.output
-            )
+            () => planIssue(this.supervisor, this.moltAgentId, payload, inspectOutput)
           );
           pipelineRun.stages.push(planResult);
-          if (planResult.status === "failed")
-            throw new Error(`Plan failed: ${planResult.error}`);
+          if (planResult.status === "failed") throw new Error(`Plan failed: ${planResult.error}`);
           const branchName = `moxxy/issue-${payload.issueNumber}`;
-          const workflow = buildWorkflow(
-            payload,
-            planResult.output,
-            branchName
-          );
+          const workflow = buildWorkflow(payload, planResult.output, branchName);
           const implementResult = await this.runStage(
             "implement",
             () => implementIssue(this.supervisor, this.moltAgentId, payload, workflow)
@@ -23801,18 +23851,17 @@ var init_dist7 = __esm({
           if (implementResult.status === "failed")
             throw new Error(`Implement failed: ${implementResult.error}`);
           pipelineRun.branchName = branchName;
-          const prNumber = await this.github.createPR(
-            payload.repo.owner,
-            payload.repo.name,
-            {
-              title: `[Moxxy] ${payload.title}`,
-              body: `Closes #${payload.issueNumber}
+          const classificationNote = pipelineRun.classification ? `
 
-Automated implementation by Moxxy.`,
-              head: branchName,
-              base: payload.repo.defaultBranch
-            }
-          );
+**Classification:** ${pipelineRun.classification.type} (${pipelineRun.classification.priority} priority, ${pipelineRun.classification.complexity} complexity)` : "";
+          const prNumber = await this.github.createPR(payload.repo.owner, payload.repo.name, {
+            title: `[Moxxy] ${payload.title}`,
+            body: `Closes #${payload.issueNumber}
+
+Automated implementation by Moxxy.${classificationNote}`,
+            head: branchName,
+            base: payload.repo.defaultBranch
+          });
           pipelineRun.prNumber = prNumber;
           pipelineRun.status = "completed";
           pipelineRun.updatedAt = Date.now();
@@ -23820,7 +23869,7 @@ Automated implementation by Moxxy.`,
             payload.repo.owner,
             payload.repo.name,
             payload.issueNumber,
-            `\u2705 Implementation complete! PR #${prNumber} created.`
+            buildSuccessComment(pipelineRun, payload)
           );
           return pipelineRun;
         } catch (error2) {
@@ -23830,7 +23879,7 @@ Automated implementation by Moxxy.`,
             payload.repo.owner,
             payload.repo.name,
             payload.issueNumber,
-            `\u274C Pipeline failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+            buildFailureComment(pipelineRun, error2)
           ).catch(() => {
           });
           return pipelineRun;
@@ -23856,12 +23905,87 @@ Automated implementation by Moxxy.`,
         }
       }
     };
+    WebhookServer = class {
+      server = null;
+      app;
+      config;
+      constructor(config) {
+        this.config = config;
+        this.app = new Hono2();
+        this.setupRoutes();
+      }
+      setupRoutes() {
+        this.app.get("/health", (c) => {
+          return c.json({ status: "ok", timestamp: Date.now() });
+        });
+        this.app.post(this.config.path, async (c) => {
+          try {
+            const rawBody = await c.req.text();
+            if (this.config.secret) {
+              const signature = c.req.header("x-hub-signature-256") || "";
+              if (!signature) {
+                return c.json({ error: "Missing signature" }, 401);
+              }
+              if (!verifyWebhookSignature(rawBody, signature, this.config.secret)) {
+                return c.json({ error: "Invalid signature" }, 401);
+              }
+            }
+            const body = JSON.parse(rawBody);
+            const event = c.req.header("x-github-event") || "";
+            if (event === "issues") {
+              const payload = parseIssuePayload(body);
+              if (payload) {
+                this.config.onIssue(payload).catch((err) => {
+                  console.error("Error processing issue webhook:", err);
+                });
+              }
+            }
+            return c.json({ received: true });
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : String(error2);
+            throw new GitHubWebhookError(
+              `Failed to process webhook: ${message}`,
+              error2 instanceof Error ? error2 : void 0
+            );
+          }
+        });
+      }
+      async start() {
+        return new Promise((resolve) => {
+          this.server = serve(
+            {
+              fetch: this.app.fetch,
+              port: this.config.port,
+              hostname: this.config.host
+            },
+            () => {
+              resolve();
+            }
+          );
+        });
+      }
+      async stop() {
+        if (this.server) {
+          await new Promise((resolve, reject) => {
+            this.server.close((err) => {
+              if (err) {
+                reject(err);
+              } else {
+                resolve();
+              }
+            });
+          });
+          this.server = null;
+        }
+      }
+    };
     GitHubIntegration = class extends BaseIntegration {
       client;
       webhookServer;
       pipeline;
       config;
       watchedRepos = [];
+      activeIssues = /* @__PURE__ */ new Map();
       constructor() {
         super("github", "github");
       }
@@ -23871,7 +23995,8 @@ Automated implementation by Moxxy.`,
         this.pipeline = new IssuePipeline(
           this.config.supervisor,
           this.config.moltAgentId,
-          this.client
+          this.client,
+          this.config.enabledStages
         );
         await this.client.verifyAuth();
         this.webhookServer = new WebhookServer({
@@ -23889,6 +24014,11 @@ Automated implementation by Moxxy.`,
           await this.webhookServer.stop();
         }
         this.watchedRepos = [];
+        this.activeIssues.clear();
+      }
+      async watchRepos(repos) {
+        this.watchedRepos.push(...repos);
+        this.emit("watching", { repos: this.watchedRepos });
       }
       async onWatch(targets) {
         for (const target of targets) {
@@ -23905,21 +24035,31 @@ Automated implementation by Moxxy.`,
         this.emit("watching", { repos: this.watchedRepos });
       }
       async onUnwatch(targets) {
-        this.watchedRepos = this.watchedRepos.filter(
-          (r) => !targets.includes(`${r.owner}/${r.repo}`)
-        );
+        this.watchedRepos = this.watchedRepos.filter((r) => !targets.includes(`${r.owner}/${r.repo}`));
       }
       async handleIssue(payload) {
         const watched = this.watchedRepos.find(
           (r) => r.owner === payload.repo.owner && r.repo === payload.repo.name
         );
         if (!watched) return;
+        const eventKey = `issues.${payload.action}`;
+        if (watched.enabledEvents && !watched.enabledEvents.includes(eventKey)) {
+          return;
+        }
+        const issueKey = `${payload.repo.owner}/${payload.repo.name}#${payload.issueNumber}`;
+        if (this.activeIssues.has(issueKey)) {
+          this.emit("issue:skipped", { key: issueKey, reason: "already processing" });
+          return;
+        }
+        this.activeIssues.set(issueKey, `pipeline-${Date.now()}`);
         this.emit("issue:received", payload);
         try {
           const run2 = await this.pipeline.run(payload);
           this.emit("pipeline:completed", run2);
         } catch (error2) {
           this.emit("pipeline:error", { issue: payload, error: error2 });
+        } finally {
+          this.activeIssues.delete(issueKey);
         }
       }
     };
@@ -23942,7 +24082,9 @@ async function createSDK(config) {
     return { sdk: sdk2, sdkName };
   }
   if (!config.gateway) {
-    throw new Error('Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".');
+    throw new Error(
+      'Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".'
+    );
   }
   const { MoltSDK: MoltSDK2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
   const sdk = await MoltSDK2.create({
@@ -23996,17 +24138,16 @@ function registerStartCommand(program) {
           webhook: webhookConfig,
           sdk,
           supervisor,
-          moltAgentId: agentId || ""
+          moltAgentId: agentId || "",
+          enabledStages: config.pipeline?.enabledStages
         });
         webhookSpinner.succeed(
           `Webhook server listening on ${import_chalk.default.cyan(`${webhookConfig.host}:${webhookConfig.port}${webhookConfig.path}`)}`
         );
         if (config.repos.length > 0) {
-          const watchSpinner = spinner(
-            `Watching ${config.repos.length} repositories`
-          );
+          const watchSpinner = spinner(`Watching ${config.repos.length} repositories`);
+          await github.watchRepos(config.repos);
           const targets = config.repos.map((r) => `${r.owner}/${r.repo}`);
-          await github.watch(targets);
           watchSpinner.succeed(
             `Watching ${import_chalk.default.bold(String(targets.length))} repositories: ${targets.join(", ")}`
           );
@@ -24209,6 +24350,19 @@ async function interactiveInit() {
     }
   ]);
   if (!shared.githubToken) return null;
+  const { pipelineStages } = await (0, import_prompts.default)({
+    type: "multiselect",
+    name: "pipelineStages",
+    message: "Pipeline stages to enable",
+    choices: [
+      { title: "Triage", value: "triage", selected: true },
+      { title: "Research", value: "research", selected: true },
+      { title: "Inspect", value: "inspect", selected: true },
+      { title: "Plan", value: "plan", selected: true },
+      { title: "Implement", value: "implement", selected: true }
+    ],
+    hint: "- Space to toggle. Plan & Implement are always on."
+  });
   return {
     sdk,
     gatewayUrl,
@@ -24219,22 +24373,238 @@ async function interactiveInit() {
     githubToken: shared.githubToken,
     webhookSecret: shared.webhookSecret || void 0,
     webhookPort: String(shared.webhookPort ?? 3456),
-    agentId: shared.agentId || void 0
+    agentId: shared.agentId || void 0,
+    pipelineStages: pipelineStages?.length ? pipelineStages : void 0
   };
 }
-var import_prompts, import_chalk2;
+async function interactiveConfig(manager) {
+  const config = manager.getConfig();
+  console.log();
+  console.log(import_chalk2.default.bold.cyan("  Moxxy Config Editor"));
+  console.log(import_chalk2.default.dim('  Select a section to edit. Ctrl+C or "Done" to exit.\n'));
+  while (true) {
+    const { group } = await (0, import_prompts.default)({
+      type: "select",
+      name: "group",
+      message: "Config section",
+      choices: [...CONFIG_GROUPS]
+    });
+    if (!group || group === "done") break;
+    switch (group) {
+      case "sdk":
+        await editSDK(manager, config);
+        break;
+      case "github":
+        await editGitHub(manager, config);
+        break;
+      case "webhook":
+        await editWebhook(manager, config);
+        break;
+      case "pipeline":
+        await editPipeline(manager, config);
+        break;
+      case "agent":
+        await editAgent(manager, config);
+        break;
+    }
+  }
+}
+async function editSDK(manager, config) {
+  const { provider } = await (0, import_prompts.default)({
+    type: "select",
+    name: "provider",
+    message: "SDK provider",
+    choices: [
+      { title: "Molt", value: "molt" },
+      { title: "Claude", value: "claude" }
+    ],
+    initial: config.sdk === "claude" ? 1 : 0
+  });
+  if (!provider) return;
+  if (provider === "molt") {
+    const result = await (0, import_prompts.default)([
+      {
+        type: "text",
+        name: "gatewayUrl",
+        message: "Gateway URL",
+        initial: config.gateway?.url || ""
+      },
+      {
+        type: "text",
+        name: "authToken",
+        message: "Auth token",
+        initial: config.gateway?.authToken || ""
+      }
+    ]);
+    if (result.gatewayUrl === void 0) return;
+    await manager.set("sdk", "molt");
+    await manager.set("gateway", {
+      url: result.gatewayUrl,
+      authToken: result.authToken || void 0
+    });
+  } else {
+    const result = await (0, import_prompts.default)([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "API key",
+        initial: config.claude?.apiKey || ""
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Model",
+        initial: config.claude?.model || "claude-sonnet-4-5"
+      },
+      {
+        type: "text",
+        name: "cliPath",
+        message: "CLI path",
+        initial: config.claude?.cliPath || "claude"
+      }
+    ]);
+    if (result.model === void 0) return;
+    await manager.set("sdk", "claude");
+    await manager.set("claude", {
+      apiKey: result.apiKey || void 0,
+      model: result.model,
+      cliPath: result.cliPath
+    });
+  }
+  console.log(import_chalk2.default.green("  SDK config updated.\n"));
+}
+async function editGitHub(manager, config) {
+  const result = await (0, import_prompts.default)([
+    {
+      type: "password",
+      name: "token",
+      message: "GitHub token",
+      initial: config.github?.token || ""
+    },
+    {
+      type: "password",
+      name: "webhookSecret",
+      message: "Webhook secret",
+      initial: config.github?.webhookSecret || ""
+    }
+  ]);
+  if (result.token === void 0) return;
+  await manager.set("github", {
+    token: result.token,
+    webhookSecret: result.webhookSecret || void 0
+  });
+  console.log(import_chalk2.default.green("  GitHub config updated.\n"));
+}
+async function editWebhook(manager, config) {
+  const webhook = config.webhook || { port: 3456, host: "0.0.0.0", path: "/webhook/github" };
+  const result = await (0, import_prompts.default)([
+    {
+      type: "number",
+      name: "port",
+      message: "Port",
+      initial: webhook.port
+    },
+    {
+      type: "text",
+      name: "host",
+      message: "Host",
+      initial: webhook.host
+    },
+    {
+      type: "text",
+      name: "path",
+      message: "Path",
+      initial: webhook.path
+    }
+  ]);
+  if (result.port === void 0) return;
+  await manager.set("webhook", {
+    port: result.port,
+    host: result.host,
+    path: result.path
+  });
+  console.log(import_chalk2.default.green("  Webhook config updated.\n"));
+}
+async function editPipeline(manager, config) {
+  const currentStages = config.pipeline?.enabledStages ?? [...PIPELINE_STAGES];
+  const currentSet = new Set(currentStages);
+  const { stages } = await (0, import_prompts.default)({
+    type: "multiselect",
+    name: "stages",
+    message: "Enabled pipeline stages",
+    choices: PIPELINE_STAGES.map((s) => ({
+      title: s.charAt(0).toUpperCase() + s.slice(1),
+      value: s,
+      selected: currentSet.has(s)
+    })),
+    hint: "- Space to toggle. Plan & Implement are always on."
+  });
+  if (!stages) return;
+  const final = [...stages];
+  if (!final.includes("plan")) final.push("plan");
+  if (!final.includes("implement")) final.push("implement");
+  await manager.set("pipeline", { enabledStages: final });
+  console.log(import_chalk2.default.green("  Pipeline config updated.\n"));
+}
+async function editAgent(manager, config) {
+  const agent = config.agent || {};
+  const result = await (0, import_prompts.default)([
+    {
+      type: "text",
+      name: "moltAgentId",
+      message: "Agent ID",
+      initial: agent.moltAgentId || ""
+    },
+    {
+      type: "number",
+      name: "maxConcurrentTasks",
+      message: "Max concurrent tasks",
+      initial: agent.maxConcurrentTasks || 1
+    }
+  ]);
+  if (result.moltAgentId === void 0) return;
+  await manager.set("agent", {
+    moltAgentId: result.moltAgentId || void 0,
+    maxConcurrentTasks: result.maxConcurrentTasks || 1
+  });
+  console.log(import_chalk2.default.green("  Agent config updated.\n"));
+}
+var import_chalk2, import_prompts, CONFIG_GROUPS;
 var init_prompt = __esm({
   "src/utils/prompt.ts"() {
     "use strict";
-    import_prompts = __toESM(require("prompts"));
+    init_dist();
     import_chalk2 = __toESM(require("chalk"));
+    import_prompts = __toESM(require("prompts"));
+    CONFIG_GROUPS = [
+      { title: "SDK Provider", value: "sdk" },
+      { title: "GitHub", value: "github" },
+      { title: "Webhook", value: "webhook" },
+      { title: "Pipeline Stages", value: "pipeline" },
+      { title: "Agent", value: "agent" },
+      { title: "Done", value: "done" }
+    ];
   }
 });
 
 // src/commands/config.ts
 function registerConfigCommand(program) {
   const config = program.command("config").description("Manage Moxxy configuration");
-  config.command("init").description("Initialize Moxxy configuration").option("--sdk <provider>", "SDK provider (molt or claude)").option("--github-token <token>", "GitHub personal access token").option("--gateway-url <url>", "Gateway URL (molt SDK)").option("--auth-token <token>", "Gateway auth token (molt SDK)").option("--claude-api-key <key>", "Anthropic API key (claude SDK)").option("--claude-model <model>", "Claude model (claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (claude SDK)", "claude").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").action(async (options) => {
+  config.action(async () => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+    } catch {
+      error("No config found. Run 'moxxy config init' first.");
+      process.exitCode = 1;
+      return;
+    }
+    await interactiveConfig(manager);
+  });
+  config.command("init").description("Initialize Moxxy configuration").option("--sdk <provider>", "SDK provider (molt or claude)").option("--github-token <token>", "GitHub personal access token").option("--gateway-url <url>", "Gateway URL (molt SDK)").option("--auth-token <token>", "Gateway auth token (molt SDK)").option("--claude-api-key <key>", "Anthropic API key (claude SDK)").option("--claude-model <model>", "Claude model (claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (claude SDK)", "claude").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").option(
+    "--pipeline-stages <stages>",
+    "Comma-separated pipeline stages (triage,research,inspect,plan,implement)"
+  ).action(async (options) => {
     if (!options.sdk) {
       const result = await interactiveInit();
       if (!result) {
@@ -24259,6 +24629,14 @@ function registerConfigCommand(program) {
       process.exitCode = 1;
       return;
     }
+    let enabledStages;
+    if (options.pipelineStages) {
+      if (typeof options.pipelineStages === "string") {
+        enabledStages = options.pipelineStages.split(",").map((s) => s.trim());
+      } else if (Array.isArray(options.pipelineStages)) {
+        enabledStages = options.pipelineStages;
+      }
+    }
     const manager = new ConfigManager();
     try {
       await manager.init({
@@ -24273,6 +24651,7 @@ function registerConfigCommand(program) {
         },
         repos: [],
         agent: options.agentId ? { moltAgentId: options.agentId } : void 0,
+        pipeline: enabledStages ? { enabledStages } : void 0,
         claude: sdk === "claude" ? {
           apiKey: options.claudeApiKey,
           cliPath: options.claudeCliPath,