debug-run 0.5.8 → 0.5.9

package/README.md

@@ -143,6 +143,8 @@ Options:
   --attach                          Attach to running process
   --pid <id>                        Process ID to attach to
   --env <key=value...>              Environment variables
+  --compact                         Enable compact output for reduced token usage
+  --stack-limit <N>                 Max stack frames to include (default: 3 in compact)
 
 Commands:
   list-adapters                     List available debug adapters
@@ -336,6 +338,35 @@ When an assertion fails, you get an `assertion_failed` event with:
 
 Assertions are checked at breakpoints, during stepping, and during trace mode.
 
+### Compact output mode (for AI agents)
+
+Reduce token usage by 40-60% with compact output:
+
+```bash
+npx debug-run ./app.dll \
+  -a dotnet \
+  -b "src/OrderService.cs:45" \
+  --compact \
+  --pretty
+```
+
+Compact mode applies these optimizations:
+- **Stack trace limiting**: Only top 3 frames by default (configurable with `--stack-limit`)
+- **Internal frame filtering**: Removes node_modules, runtime internals, webpack frames
+- **Path abbreviation**: `~/project/src/file.ts` instead of `/Users/name/project/src/file.ts`
+- **Variable diffing**: On repeated breakpoint hits, only reports changed variables (`_diff` key)
+- **Trace path collapsing**: Consecutive identical locations collapsed to `functionName (x5)`
+
+Example compact output vs verbose:
+
+```json
+// Compact (~60 tokens)
+{"type":"breakpoint_hit","location":{"file":".../src/OrderService.cs","line":45,"function":"ProcessOrder"},"stackTrace":[{"function":"ProcessOrder","file":".../src/OrderService.cs","line":45}],"locals":{"order":{"type":"OrderDto","value":{"Id":"abc-123","Total":150}}}}
+
+// Verbose (~180 tokens)
+{"type":"breakpoint_hit","timestamp":"2025-01-15T10:30:01.234Z","id":1,"threadId":1,"location":{"file":"/home/user/project/src/OrderService.cs","line":45,"column":12,"function":"ProcessOrder","module":"MyApp"},"stackTrace":[{"frameId":1,"function":"ProcessOrder","file":"/home/user/project/src/OrderService.cs","line":45,"column":12,"module":"MyApp"},{"frameId":2,"function":"Main","file":"/home/user/project/src/Program.cs","line":10,"column":5},...],"locals":{"order":{"type":"OrderDto","value":{"Id":"abc-123","Total":150,"CreatedAt":"2025-01-15T00:00:00Z","Status":"pending",...}},"this":{...}}}
+```
+
 ### Trace mode (follow execution path)
 
 Automatically step through code after hitting a breakpoint:

package/dist/index.cjs

@@ -3066,7 +3066,6 @@ var path = __toESM(require("node:path"), 1);
 var os = __toESM(require("node:os"), 1);
 var import_promises2 = require("node:stream/promises");
 var import_node_stream = require("node:stream");
-var import_node_url = require("node:url");
 var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
 var NETCOREDBG_VERSION = "3.1.3-1062";
 var NETCOREDBG_BASE_URL = `https://github.com/Samsung/netcoredbg/releases/download/${NETCOREDBG_VERSION}`;
@@ -3119,10 +3118,14 @@ function getDownloadUrl() {
   const filename = `netcoredbg-${info.os}-${info.arch}.${info.archiveExt}`;
   return `${NETCOREDBG_BASE_URL}/${filename}`;
 }
+function getDebugRunHome() {
+  if (process.env.DEBUG_RUN_HOME) {
+    return process.env.DEBUG_RUN_HOME;
+  }
+  return path.join(os.homedir(), ".debug-run");
+}
 function getAdaptersDir() {
-  const currentFilePath = (0, import_node_url.fileURLToPath)(__importMetaUrl);
-  const packageRoot = path.resolve(path.dirname(currentFilePath), "..", "..");
-  return path.join(packageRoot, "bin", "adapters");
+  return path.join(getDebugRunHome(), "adapters");
 }
 function getNetcoredbgPath() {
   const info = getPlatformInfo();
@@ -3144,6 +3147,9 @@ async function installNetcoredbg(onProgress) {
   if (!response.ok) {
     throw new Error(`Failed to download netcoredbg: ${response.statusText}`);
   }
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
   const fileStream = (0, import_node_fs.createWriteStream)(archivePath);
   await (0, import_promises2.pipeline)(import_node_stream.Readable.fromWeb(response.body), fileStream);
   log("Extracting...");
@@ -3177,6 +3183,9 @@ async function installJsDebug(onProgress) {
   if (!response.ok) {
     throw new Error(`Failed to download js-debug: ${response.statusText}`);
   }
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
   const fileStream = (0, import_node_fs.createWriteStream)(archivePath);
   await (0, import_promises2.pipeline)(import_node_stream.Readable.fromWeb(response.body), fileStream);
   log("Extracting...");
@@ -3294,7 +3303,7 @@ function findVsdbg() {
     const arch3 = os2.arch();
     const vsdbgDirs = [];
     if (platform3 === "win32") {
-      vsdbgDirs.push("vsdbg", "win32", "x64", "x86");
+      vsdbgDirs.push("vsdbg", "win32", "x64", "x86", "x86_64");
     } else if (platform3 === "darwin") {
       vsdbgDirs.push(
         arch3 === "arm64" ? "arm64" : "x86_64",
@@ -3974,7 +3983,7 @@ var DapTransport = class extends import_node_events.EventEmitter {
       command,
       arguments: args
     };
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve9, reject) => {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(seq);
         reject(new Error(`Request '${command}' timed out after ${this.requestTimeout}ms`));
@@ -3983,7 +3992,7 @@ var DapTransport = class extends import_node_events.EventEmitter {
         resolve: (response) => {
           clearTimeout(timeout);
           if (response.success) {
-            resolve10(response.body);
+            resolve9(response.body);
           } else {
             reject(new Error(response.message || `Request '${command}' failed`));
           }
@@ -4289,8 +4298,8 @@ var DapClient = class extends import_node_events2.EventEmitter {
   async initialize(args = {}) {
     this.ensureConnected();
     let initializedResolve;
-    const initializedPromise = new Promise((resolve10) => {
-      initializedResolve = resolve10;
+    const initializedPromise = new Promise((resolve9) => {
+      initializedResolve = resolve9;
     });
     this.once("initialized", () => initializedResolve());
     const response = await this.transport.sendRequest("initialize", {
@@ -4308,7 +4317,7 @@ var DapClient = class extends import_node_events2.EventEmitter {
     });
     this.capabilities = response?.capabilities || response || {};
     const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("Timeout waiting for initialized event")), 1e4);
+      setTimeout(() => reject(new Error("Timeout waiting for initialized event")), 500);
     });
     try {
       await Promise.race([initializedPromise, timeoutPromise]);
@@ -4501,7 +4510,7 @@ var SocketDapTransport = class extends import_node_events3.EventEmitter {
    * Connect to the DAP server
    */
   async connect() {
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve9, reject) => {
       this.socket = (0, import_node_net.connect)({
         host: this.options.host,
         port: this.options.port
@@ -4513,7 +4522,7 @@ var SocketDapTransport = class extends import_node_events3.EventEmitter {
       const onConnect = () => {
         this.socket?.removeListener("error", onError);
         this.setupSocket();
-        resolve10();
+        resolve9();
       };
       this.socket.once("error", onError);
       this.socket.once("connect", onConnect);
@@ -4547,7 +4556,7 @@ var SocketDapTransport = class extends import_node_events3.EventEmitter {
       command,
       arguments: args
     };
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve9, reject) => {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(seq);
         reject(new Error(`Request '${command}' timed out after ${this.requestTimeout}ms`));
@@ -4556,7 +4565,7 @@ var SocketDapTransport = class extends import_node_events3.EventEmitter {
         resolve: (response) => {
           clearTimeout(timeout);
           if (response.success) {
-            resolve10(response.body);
+            resolve9(response.body);
           } else {
             reject(new Error(response.message || `Request '${command}' failed`));
           }
@@ -4738,7 +4747,7 @@ var SocketDapClient = class extends import_node_events4.EventEmitter {
       this.emit("serverError", error);
     });
     const delay = this.options.connectDelay ?? 1e3;
-    await new Promise((resolve10) => setTimeout(resolve10, delay));
+    await new Promise((resolve9) => setTimeout(resolve9, delay));
     this.transport = new SocketDapTransport({
       host: this.options.host || "localhost",
       port: this.options.port,
@@ -5077,20 +5086,20 @@ var SocketDapClient = class extends import_node_events4.EventEmitter {
     if (process.env.DEBUG_DAP) {
       console.error("[DAP child] Initialize response received, waiting for initialized event...");
     }
-    await new Promise((resolve10) => {
+    await new Promise((resolve9) => {
       let resolved = false;
       const onInitialized = () => {
         if (resolved) return;
         resolved = true;
         this.childTransport?.removeListener("event:initialized", onInitialized);
-        resolve10();
+        resolve9();
       };
       this.childTransport.on("event:initialized", onInitialized);
       setTimeout(() => {
         if (resolved) return;
         resolved = true;
         this.childTransport?.removeListener("event:initialized", onInitialized);
-        resolve10();
+        resolve9();
       }, 500);
     });
     if (process.env.DEBUG_DAP) {
@@ -5129,16 +5138,38 @@ var SocketDapClient = class extends import_node_events4.EventEmitter {
 };
 
 // src/output/formatter.ts
+var INTERNAL_PATTERNS = [
+  /^node:/,
+  /node_modules/,
+  /internal\//,
+  /<anonymous>/,
+  /^native /,
+  /\[native code\]/,
+  /webpack:/,
+  /^async /,
+  /^Module\./,
+  /processTicksAndRejections/,
+  /^RunMain$/,
+  /^bootstrap_node\.js$/,
+  /^_compile$/,
+  /^\.js$/
+];
 var OutputFormatter = class {
   stream;
   pretty;
   include;
   exclude;
+  compact;
+  stackLimit;
+  /** Track previous locals for variable diffing in compact mode */
+  previousLocals = {};
   constructor(options = {}) {
     this.stream = options.stream ?? process.stdout;
     this.pretty = options.pretty ?? false;
     this.include = options.include ? new Set(options.include) : void 0;
     this.exclude = options.exclude ? new Set(options.exclude) : void 0;
+    this.compact = options.compact ?? false;
+    this.stackLimit = options.stackLimit ?? (options.compact ? 3 : Infinity);
   }
   /**
    * Check if an event type should be emitted based on include/exclude filters
@@ -5159,9 +5190,248 @@ var OutputFormatter = class {
     if (!this.shouldEmit(event.type)) {
       return;
     }
-    const json = this.pretty ? JSON.stringify(event, null, 2) : JSON.stringify(event);
+    const outputEvent = this.compact ? this.compactifyEvent(event) : event;
+    const json = this.pretty ? JSON.stringify(outputEvent, null, 2) : JSON.stringify(outputEvent);
     this.stream.write(json + "\n");
   }
+  /**
+   * Check if a stack frame is an internal/runtime frame
+   */
+  isInternalFrame(frame) {
+    const file = frame.file ?? "";
+    const fn = frame.function ?? "";
+    return INTERNAL_PATTERNS.some((pattern) => pattern.test(file) || pattern.test(fn));
+  }
+  /**
+   * Filter and limit stack frames for compact output
+   */
+  compactifyStackTrace(frames) {
+    const userFrames = frames.filter((frame) => !this.isInternalFrame(frame));
+    const relevantFrames = userFrames.length > 0 ? userFrames : frames.slice(0, 1);
+    const limitedFrames = relevantFrames.slice(0, this.stackLimit);
+    return limitedFrames.map((frame) => ({
+      ...frame,
+      file: frame.file ? this.abbreviatePath(frame.file) : null
+    }));
+  }
+  /**
+   * Abbreviate a file path for compact output
+   */
+  abbreviatePath(filePath) {
+    let abbreviated = filePath;
+    const nodeModulesMatch = abbreviated.match(/node_modules\/(.+)/);
+    if (nodeModulesMatch) {
+      const modulePath = nodeModulesMatch[1];
+      const moduleSegments = modulePath.split("/");
+      if (moduleSegments.length > 3) {
+        abbreviated = `<node_modules>/${moduleSegments.slice(0, 2).join("/")}/...`;
+      } else {
+        abbreviated = `<node_modules>/${modulePath}`;
+      }
+      return abbreviated;
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    if (homeDir && abbreviated.startsWith(homeDir)) {
+      abbreviated = "~" + abbreviated.slice(homeDir.length);
+    }
+    const segments = abbreviated.split("/");
+    if (segments.length > 4) {
+      abbreviated = ".../" + segments.slice(-3).join("/");
+    }
+    return abbreviated;
+  }
+  /**
+   * Abbreviate a source location for compact output
+   */
+  compactifyLocation(location) {
+    return {
+      ...location,
+      file: this.abbreviatePath(location.file),
+      // Remove module in compact mode as it's often redundant
+      module: void 0
+    };
+  }
+  /**
+   * Compact locals by computing diff from previous state
+   * Returns only changed variables
+   */
+  compactifyLocals(locals) {
+    const isFirstCapture = Object.keys(this.previousLocals).length === 0;
+    if (isFirstCapture) {
+      this.previousLocals = { ...locals };
+      return this.abbreviateLocals(locals);
+    }
+    const diff = {};
+    let hasChanges = false;
+    for (const [name, value] of Object.entries(locals)) {
+      const previousValue = this.previousLocals[name];
+      const currentJson = JSON.stringify(value);
+      const previousJson = previousValue !== void 0 ? JSON.stringify(previousValue) : void 0;
+      if (currentJson !== previousJson) {
+        diff[name] = value;
+        hasChanges = true;
+      }
+    }
+    for (const name of Object.keys(this.previousLocals)) {
+      if (!(name in locals)) {
+        hasChanges = true;
+        diff[name] = { type: "deleted", value: null };
+      }
+    }
+    this.previousLocals = { ...locals };
+    if (hasChanges) {
+      return { _diff: this.abbreviateLocals(diff) };
+    }
+    return {};
+  }
+  /**
+   * Abbreviate local variable values for compact output
+   */
+  abbreviateLocals(locals) {
+    const abbreviated = {};
+    for (const [name, value] of Object.entries(locals)) {
+      abbreviated[name] = this.abbreviateValue(value);
+    }
+    return abbreviated;
+  }
+  /**
+   * Abbreviate a single variable value for compact output
+   */
+  abbreviateValue(value) {
+    if (typeof value.value === "string" && value.value.length > 100) {
+      return {
+        ...value,
+        value: value.value.slice(0, 100) + "..."
+      };
+    }
+    if (Array.isArray(value.value) && value.value.length > 5) {
+      const abbreviated = value.value.slice(0, 3);
+      return {
+        ...value,
+        value: `[${abbreviated.join(", ")}, ... (${value.value.length} items)]`
+      };
+    }
+    return value;
+  }
+  /**
+   * Apply compact transformations to an event
+   */
+  compactifyEvent(event) {
+    switch (event.type) {
+      case "breakpoint_hit": {
+        const compacted = {
+          ...event,
+          location: this.compactifyLocation(event.location),
+          stackTrace: this.compactifyStackTrace(event.stackTrace)
+        };
+        if (event.locals && Object.keys(event.locals).length > 0) {
+          const compactedLocals = this.compactifyLocals(event.locals);
+          compacted.locals = compactedLocals;
+        }
+        return compacted;
+      }
+      case "exception_thrown": {
+        const compacted = {
+          ...event,
+          location: this.compactifyLocation(event.location)
+        };
+        if (event.exception.stackTrace) {
+          compacted.exception = {
+            ...event.exception,
+            stackTrace: this.abbreviateStackTraceString(event.exception.stackTrace)
+          };
+        }
+        if (event.locals && Object.keys(event.locals).length > 0) {
+          const compactedLocals = this.compactifyLocals(event.locals);
+          compacted.locals = compactedLocals;
+        }
+        return compacted;
+      }
+      case "step_completed": {
+        return {
+          ...event,
+          location: this.compactifyLocation(event.location),
+          stackTrace: this.compactifyStackTrace(event.stackTrace),
+          locals: this.abbreviateLocals(event.locals)
+        };
+      }
+      case "trace_step": {
+        return {
+          ...event,
+          location: this.compactifyLocation(event.location)
+        };
+      }
+      case "trace_completed": {
+        const compactedPath = event.path.map((loc) => this.compactifyLocation(loc));
+        const collapsedPath = [];
+        let repeatCount = 1;
+        for (let i = 0; i < compactedPath.length; i++) {
+          const current = compactedPath[i];
+          const next = compactedPath[i + 1];
+          if (next && current.file === next.file && current.line === next.line && current.function === next.function) {
+            repeatCount++;
+          } else {
+            if (repeatCount > 1) {
+              collapsedPath.push({
+                ...current,
+                function: `${current.function} (x${repeatCount})`
+              });
+            } else {
+              collapsedPath.push(current);
+            }
+            repeatCount = 1;
+          }
+        }
+        return {
+          ...event,
+          path: collapsedPath,
+          finalLocation: this.compactifyLocation(event.finalLocation),
+          stackTrace: this.compactifyStackTrace(event.stackTrace),
+          locals: this.abbreviateLocals(event.locals)
+        };
+      }
+      case "assertion_failed": {
+        return {
+          ...event,
+          location: this.compactifyLocation(event.location),
+          stackTrace: this.compactifyStackTrace(event.stackTrace),
+          locals: this.abbreviateLocals(event.locals)
+        };
+      }
+      case "session_start": {
+        const compacted = { ...event };
+        if (compacted.program) {
+          compacted.program = this.abbreviatePath(compacted.program);
+        }
+        if (compacted.cwd) {
+          compacted.cwd = this.abbreviatePath(compacted.cwd);
+        }
+        return compacted;
+      }
+      default:
+        return event;
+    }
+  }
+  /**
+   * Abbreviate a stack trace string (from exception)
+   */
+  abbreviateStackTraceString(stackTrace) {
+    const lines = stackTrace.split("\n");
+    const userLines = lines.filter((line) => {
+      return !INTERNAL_PATTERNS.some((pattern) => pattern.test(line));
+    });
+    const limitedLines = userLines.slice(0, this.stackLimit);
+    return limitedLines.map((line) => this.abbreviatePathsInLine(line)).join("\n");
+  }
+  /**
+   * Abbreviate file paths within a line of text
+   */
+  abbreviatePathsInLine(line) {
+    return line.replace(/(?:at\s+)?(\/[^\s:]+)/g, (match, path12) => {
+      const abbreviated = this.abbreviatePath(path12);
+      return match.replace(path12, abbreviated);
+    });
+  }
   /**
    * Create an event with timestamp
    */
@@ -6397,10 +6667,17 @@ var DebugSession = class {
   traceInitialStackDepth = 0;
   /** Previous locals for variable diffing (only used when diffVars is enabled) */
   previousLocals = {};
+  /** Whether we are stepping to evaluate expressions after line execution */
+  isEvalAfterStep = false;
+  /** Pending data for eval-after-step (original breakpoint data) */
+  evalAfterStepData = null;
   sessionPromise = null;
   sessionResolve = null;
-  _sessionReject = null;
   timeoutHandle = null;
+  /** Error that occurred during session (timeout, etc.) - used to avoid unhandled promise rejections */
+  sessionError = null;
+  /** Whether session_end event has been emitted (to prevent duplicate emissions) */
+  sessionEndEmitted = false;
   constructor(config, formatter) {
     this.config = config;
     this.formatter = formatter ?? new OutputFormatter();
@@ -6410,6 +6687,8 @@ var DebugSession = class {
    */
   async run() {
     this.startTime = Date.now();
+    this.sessionError = null;
+    this.sessionEndEmitted = false;
     if (this.config.attach && this.config.pid) {
       this.formatter.sessionStartAttach(this.config.adapter.name, this.config.pid);
     } else {
@@ -6420,9 +6699,8 @@ var DebugSession = class {
         this.config.cwd
       );
     }
-    this.sessionPromise = new Promise((resolve10, reject) => {
-      this.sessionResolve = resolve10;
-      this._sessionReject = reject;
+    this.sessionPromise = new Promise((resolve9) => {
+      this.sessionResolve = resolve9;
     });
     if (this.config.timeout) {
       this.timeoutHandle = setTimeout(() => {
@@ -6430,13 +6708,21 @@ var DebugSession = class {
       }, this.config.timeout);
     }
     try {
-      await this.start();
+      await Promise.race([this.start(), this.sessionPromise]);
+      if (this.sessionError) {
+        throw this.sessionError;
+      }
       await this.sessionPromise;
+      if (this.sessionError) {
+        throw this.sessionError;
+      }
     } catch (error) {
-      this.formatter.error(
-        "Session failed",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (error !== this.sessionError) {
+        this.formatter.error(
+          "Session failed",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       throw error;
     } finally {
       await this.cleanup();
@@ -6544,14 +6830,14 @@ var DebugSession = class {
    * Wait for the 'initialized' event from the debug adapter
    */
   async waitForInitialized() {
-    return new Promise((resolve10) => {
+    return new Promise((resolve9) => {
       const onInitialized = () => {
-        resolve10();
+        resolve9();
       };
       this.client.once("initialized", onInitialized);
       const timeout = setTimeout(() => {
         this.client.removeListener("initialized", onInitialized);
-        resolve10();
+        resolve9();
       }, 3e4);
       this.client.once("initialized", () => {
         clearTimeout(timeout);
@@ -6624,7 +6910,8 @@ var DebugSession = class {
         locals = await this.variableInspector.getLocals(topFrame.id);
       }
       let evaluations;
-      if (this.config.evaluations?.length && topFrame) {
+      const shouldDeferEval = this.config.evalAfterStep && reason === "breakpoint";
+      if (this.config.evaluations?.length && topFrame && !shouldDeferEval) {
         evaluations = await this.variableInspector.evaluateExpressions(
           topFrame.id,
           this.config.evaluations
@@ -6640,6 +6927,64 @@ var DebugSession = class {
         );
         return;
       }
+      if (reason === "step" && this.isEvalAfterStep && this.evalAfterStepData) {
+        this.isEvalAfterStep = false;
+        const pendingData = this.evalAfterStepData;
+        this.evalAfterStepData = null;
+        let evaluations2;
+        if (this.config.evaluations?.length && topFrame) {
+          evaluations2 = await this.variableInspector.evaluateExpressions(
+            topFrame.id,
+            this.config.evaluations
+          );
+        }
+        if (topFrame) {
+          const failed = await this.checkAssertions(topFrame.id);
+          if (failed) {
+            await this.emitAssertionFailed(
+              pendingData.threadId,
+              failed.assertion,
+              failed.value,
+              failed.error,
+              location,
+              stackTrace,
+              topFrame.id
+            );
+            this.endSession();
+            return;
+          }
+        }
+        const event2 = {
+          type: "breakpoint_hit",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          id: pendingData.breakpointId,
+          threadId: pendingData.threadId,
+          location: pendingData.originalLocation,
+          stackTrace: pendingData.originalStackTrace,
+          locals,
+          evaluations: evaluations2
+        };
+        this.formatter.emit(event2);
+        if (this.config.trace) {
+          await this.startTrace(
+            pendingData.threadId,
+            location,
+            stackResponse.stackFrames.length,
+            topFrame?.id
+          );
+          return;
+        }
+        if (this.config.steps && this.config.steps > 1) {
+          this.remainingSteps = this.config.steps - 1;
+          this.isStepping = true;
+          await this.client.next({ threadId });
+          this.state = "running";
+          return;
+        }
+        await this.client.continue({ threadId });
+        this.state = "running";
+        return;
+      }
       if (reason === "step" && this.isStepping) {
         this.stepsExecuted++;
         this.remainingSteps--;
@@ -6719,6 +7064,18 @@ var DebugSession = class {
           await this.endTrace(threadId, "breakpoint", stackTrace, topFrame?.id);
         }
         this.breakpointsHit++;
+        if (this.config.evalAfterStep && this.config.evaluations?.length) {
+          this.isEvalAfterStep = true;
+          this.evalAfterStepData = {
+            threadId,
+            originalLocation: location,
+            originalStackTrace: stackTrace,
+            breakpointId: body.hitBreakpointIds?.[0]
+          };
+          await this.client.next({ threadId });
+          this.state = "running";
+          return;
+        }
         if (topFrame) {
           const failed = await this.checkAssertions(topFrame.id);
           if (failed) {
@@ -6814,31 +7171,36 @@ var DebugSession = class {
     this.endSessionWithError(new Error(`Session timed out after ${this.config.timeout}ms`));
   }
   endSessionWithError(error) {
-    this.formatter.sessionEnd({
-      durationMs: Date.now() - this.startTime,
-      exitCode: this.exitCode,
-      breakpointsHit: this.breakpointsHit,
-      exceptionsCaught: this.exceptionsCaught,
-      stepsExecuted: this.stepsExecuted
-    });
-    if (this._sessionReject) {
-      this._sessionReject(error);
+    this.sessionError = error;
+    if (!this.sessionEndEmitted) {
+      this.sessionEndEmitted = true;
+      this.formatter.sessionEnd({
+        durationMs: Date.now() - this.startTime,
+        exitCode: this.exitCode,
+        breakpointsHit: this.breakpointsHit,
+        exceptionsCaught: this.exceptionsCaught,
+        stepsExecuted: this.stepsExecuted
+      });
+    }
+    if (this.sessionResolve) {
+      this.sessionResolve();
       this.sessionResolve = null;
-      this._sessionReject = null;
     }
   }
   endSession() {
-    this.formatter.sessionEnd({
-      durationMs: Date.now() - this.startTime,
-      exitCode: this.exitCode,
-      breakpointsHit: this.breakpointsHit,
-      exceptionsCaught: this.exceptionsCaught,
-      stepsExecuted: this.stepsExecuted
-    });
+    if (!this.sessionEndEmitted) {
+      this.sessionEndEmitted = true;
+      this.formatter.sessionEnd({
+        durationMs: Date.now() - this.startTime,
+        exitCode: this.exitCode,
+        breakpointsHit: this.breakpointsHit,
+        exceptionsCaught: this.exceptionsCaught,
+        stepsExecuted: this.stepsExecuted
+      });
+    }
     if (this.sessionResolve) {
       this.sessionResolve();
       this.sessionResolve = null;
-      this._sessionReject = null;
     }
   }
   async cleanup() {
@@ -7098,7 +7460,7 @@ async function launchTestRunner(config) {
   });
   const stdoutReader = readline.createInterface({ input: testProcess.stdout });
   const stderrReader = readline.createInterface({ input: testProcess.stderr });
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve9, reject) => {
     let foundPid = null;
     let exitedEarly = false;
     let sawDebugHint = false;
@@ -7113,7 +7475,7 @@ async function launchTestRunner(config) {
       if (match && !foundPid && sawDebugHint) {
         foundPid = parseInt(match[1], 10);
         onProgress?.(`Found testhost PID: ${foundPid} (process: ${match[2]})`);
-        resolve10({
+        resolve9({
           pid: foundPid,
           process: testProcess
         });
@@ -7211,6 +7573,10 @@ function createCli() {
     "--diff-vars",
     "Show only changed variables in trace steps instead of full dumps",
     false
+  ).option(
+    "--eval-after-step",
+    "Step once before evaluating expressions (useful for evaluating variables being assigned on the breakpoint line)",
+    false
   ).option("-o, --output <file>", "Write events to file instead of stdout").option("--include <types...>", "Only emit these event types (e.g., breakpoint_hit error)").option(
     "--exclude <types...>",
     "Suppress these event types (e.g., program_output exception_thrown)"
@@ -7241,6 +7607,14 @@ function createCli() {
     "Maximum depth to traverse exception chain (default: 10)",
     (val) => parseInt(val, 10),
     10
+  ).option(
+    "--compact",
+    "Enable compact output mode for reduced token usage (limits stack traces, filters internals, abbreviates paths)",
+    false
+  ).option(
+    "--stack-limit <count>",
+    "Maximum stack frames to include (default: 3 in compact mode, unlimited otherwise)",
+    (val) => parseInt(val, 10)
   ).action(
     async (programPath, options) => {
       if (options.testProject) {
@@ -7401,7 +7775,9 @@ async function runDebugSession(options) {
     pretty: options.pretty,
     stream: outputStream,
     include: options.include,
-    exclude: options.exclude
+    exclude: options.exclude,
+    compact: options.compact,
+    stackLimit: options.stackLimit
   });
   const session = new DebugSession(
     {
@@ -7426,6 +7802,7 @@ async function runDebugSession(options) {
       traceLimit: options.traceLimit,
       traceUntil: options.traceUntil,
       diffVars: options.diffVars,
+      evalAfterStep: options.evalAfterStep,
       // Token efficiency options
       expandServices: options.expandServices,
       showNullProps: options.showNullProps,
@@ -7549,8 +7926,8 @@ function getSkillTargets(options) {
 }
 async function installSkill(options = {}) {
   const path12 = await import("node:path");
-  const { fileURLToPath: fileURLToPath2 } = await import("node:url");
-  const moduleDir = path12.dirname(fileURLToPath2(__importMetaUrl));
+  const { fileURLToPath } = await import("node:url");
+  const moduleDir = path12.dirname(fileURLToPath(__importMetaUrl));
   const possibleSources = [
     path12.join(moduleDir, "..", ".claude", "skills", "debug-run"),
     path12.join(moduleDir, ".claude", "skills", "debug-run"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "debug-run",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "CLI tool enabling AI agents to programmatically debug code via DAP",
   "type": "module",
   "main": "dist/index.cjs",