diff --git a/command-line-debugger/module.ivy b/command-line-debugger/module.ivy
new file mode 100644
index 0000000..493f21b
--- /dev/null
+++ b/command-line-debugger/module.ivy
@@ -0,0 +1,36 @@
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<ivy-module version="2.0" xmlns:ea="http://www.easyant.org">
+    <info organisation="org.apache.easyant.tasks" module="cl-debugger"
+            status="integration" revision="0.1">
+        <ea:build module="build-std-java" revision="0.2">
+            <ea:property name="project.ivy.instance" value="easyant.ivy.instance"/>
+            <ea:property name="src.main.java" value="src/main"/>
+            <ea:property name="src.main.resources" value="src/main"/>
+            <ea:property name="resources.std.includes.pattern" value="**/*.properties"/>
+        </ea:build>
+    </info>
+    <configurations>
+        <conf name="default" visibility="public" description="runtime dependencies artifact can be used with this conf"/>
+        <conf name="test" visibility="private" description="this scope indicates that the dependency is not required for normal use of the application, and is only available for the test compilation and execution phases."/>
+        <conf name="provided" visibility="public" description="this is much like compile, but indicates you expect the JDK or a container to provide it. It is only available on the compilation classpath, and is not transitive."/>
+    </configurations>
+    <dependencies>
+        <dependency org="junit" name="junit" rev="4.4" conf="test->default"/>
+        <dependency org="org.apache.ant" name="ant" rev="1.8.2" conf="provided->default"/>
+    </dependencies>
+</ivy-module>
diff --git a/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java b/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java
index e9f60b0..aa648be 100644
--- a/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java
+++ b/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java
@@ -31,7 +31,7 @@
 			commandSupport.putAll(commands);
 		Properties props = new Properties();
 		try {
-			InputStream is = DebugCommandSet.class.getClassLoader()
+			InputStream is = Thread.currentThread().getContextClassLoader()
 					.getResourceAsStream(
 							"org/apache/ant/debugger/debug-support.properties");
 			props.load(is);
diff --git a/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java b/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java
new file mode 100644
index 0000000..4d92a82
--- /dev/null
+++ b/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java
@@ -0,0 +1,205 @@
+package org.apache.tools.ant.listener;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.ant.debugger.Auditor;
+import org.apache.ant.debugger.DebugCommandSet;
+import org.apache.ant.debugger.DebugPrompt;
+import org.apache.ant.debugger.DebugSupport;
+import org.apache.ant.debugger.DefaultAuditor;
+import org.apache.tools.ant.BuildEvent;
+import org.apache.tools.ant.BuildListener;
+import org.apache.tools.ant.MagicNames;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.PropertyDebugHelper;
+import org.apache.tools.ant.PropertyHelper;
+import org.apache.tools.ant.Target;
+import org.apache.tools.ant.input.InputHandler;
+
+// The input-listener should itself be pluggable
+/*
+ * We can probably build up a stack of targets in execution to allow dumping a stack of a target
+ * when a break point occurs?
+ *
+ * This class also doubles as a DebugSupport Command that can be used to add new targets / properties
+ * to debug at runtime.
+ */
+public class DebuggerListener implements BuildListener, DebugSupport {
+
+	/**
+	 * The project being debugged.
+	 */
+	protected Project project = null;
+
+	/**
+	 * List of all targets at which break points have been applied.
+	 */
+	protected List debugtargets = new LinkedList();
+
+	/**
+	 * Indicates if this listener instance has been initialized.
+	 */
+	protected boolean inited = false;
+
+	/**
+	 * Debugger instance.
+	 */
+	protected DebugPrompt prompt = null;
+
+	/**
+	 * Contains the current target being executed.
+	 */
+	protected Target currentTarget = null;
+
+	/**
+	 * An Auditor instance that keeps track of all changes to properties
+	 * identified by the user.
+	 */
+	protected Auditor auditor = null;
+
+	/**
+	 * InputHandler instance that may be different than the configured one.
+	 */
+	protected InputHandler inputHandler;
+
+	/**
+	 * {@link DebugCommandSet} instance that is a container for all
+	 * {@link DebugSupport} commands that may be used with this listener.
+	 */
+	protected DebugCommandSet commandHandler = new DebugCommandSet();
+
+	// List of all break point facilities to be available
+	// ==================================================
+	/**
+	 * Target break point property name
+	 */
+	public static final String DEBUG_TARGET_PROPERTY = "ant.debug.target";
+
+	/**
+	 * Exception break point property name
+	 */
+	public static final String DEBUG_EXCEPTION_PROPERTY = "ant.debug.exception";
+
+	/**
+	 * Break point when the value of a property changes or is attempted to be
+	 * changed.
+	 */
+	public static final String DEBUG_PROPERTY_CHANGE_PROPERTY = "ant.debug.property";
+
+	/**
+	 * Request to audit all attempted changes to a property
+	 */
+	public static final String AUDIT_PROPERTY_PROPERTY = "ant.audit.property";
+
+	// End of all available break points
+	// =================================
+
+	public void init(BuildEvent event) {
+		project = event.getProject();
+		project.log("Attaching DebuggerListener to the build.");
+
+	}
+
+	public void buildFinished(BuildEvent event) {
+		// Anything to do?
+	}
+
+	protected Map getDefaultCommandSupport() {
+		if (auditor instanceof DebugSupport) {
+			Map defaults = new HashMap();
+			defaults.put("trace", auditor);
+			defaults.put("add", this);
+			return defaults;
+		}
+		return null;
+	}
+
+	public void buildStarted(BuildEvent event) {
+		// set audit property helper that will help keep track of properties
+		// being set everywhere.
+		project = event.getProject();
+		PropertyHelper helper = new PropertyDebugHelper();
+		helper.setProject(project);
+		auditor = new DefaultAuditor();
+		((PropertyDebugHelper) helper).setAuditor(auditor);
+		// Is it better to set it as a project helper or as a delegate to the
+		// helper?
+		project.addReference(MagicNames.REFID_PROPERTY_HELPER, helper);
+		commandHandler.setProject(project);
+		commandHandler.init(getDefaultCommandSupport());
+		prompt = new DebugPrompt(project, commandHandler);
+		auditor.setPrompt(prompt);
+
+		// this is how the debugging starts
+		prompt.prompt("Type /? to get any help.");
+	}
+
+	public void messageLogged(BuildEvent event) {
+		// Do Nothing
+	}
+
+	public void targetFinished(BuildEvent event) {
+		currentTarget = null;
+	}
+
+	public void targetStarted(BuildEvent event) {
+		currentTarget = event.getTarget();
+		Target target = event.getTarget();
+		if (debugtargets.contains(target.getName())) {
+			prompt.prompt("Break Point at Target: " + target.getName());
+		}
+	}
+
+	public void taskFinished(BuildEvent event) {
+	}
+
+	public void taskStarted(BuildEvent event) {
+	}
+
+	/*
+	 * The following section of code customizes this class to double up as a
+	 * DebugSupport command instance so that it is possible to add
+	 * target/property break points at runtime.
+	 */
+
+	/**
+	 * The current listener as a {@link DebugSupport} command only supports add
+	 * new breakpoints.
+	 */
+	public boolean commandSupported(String command) {
+		return "add".equals(command);
+	}
+
+	public void execute(Project project, String[] params) {
+		if (params.length < 3) {
+			printUsage(project);
+			return;
+		}
+
+		if (!"property".equals(params[1]) && !"target".equals(params[1])) {
+			printUsage(project);
+			return;
+		}
+
+		boolean isproperty = "property".equals(params[1]);
+		for (int i = 2; i < params.length; i++) {
+			if (isproperty) {
+				// add as a property to be audited
+				auditor.addPropertyForAudits(params[i], project);
+				project.log("Added BreakPoint at Property: " + params[2]);
+			} else {
+				debugtargets.add(params[i]);
+				project.log("Added BreakPoint at Target: " + params[2]);
+			}
+		}
+	}
+
+	public void printUsage(Project project) {
+		project
+				.log("Some Helpful Message to add debug/property break points at runtime.");
+	}
+
+}