abapgit-agent 1.17.9 → 1.18.1

package/abap/guidelines/debug-session.md

@@ -216,13 +216,20 @@ abapgit-agent debug step   --type continue --json        # continue to next brea
 abapgit-agent debug stack  --json                        # call stack (shows which test method is active)
 ```
 
-> **`--expand` does not support table-row index notation.** `--expand "LT_DATA[1]"` returns "Variable not found". Use `--expand LT_DATA` to expand all rows, then `--name` on a specific scalar component.
+> To inspect a specific table row, use `--expand TABLE[N]`:
+> ```bash
+> abapgit-agent debug vars --expand LT_DATA[1] --json          # first row — shows its fields
+> abapgit-agent debug vars --expand LT_DATA[1]->CARRID --json  # drill into one field in row 1
+> ```
+> Use `--expand LT_DATA` (without index) to see all rows first.
 
-> **Field symbols assigned via `ASSIGNING FIELD-SYMBOL(<fs>)` do not appear in `debug vars` output.** Only named variables (`DATA`, `FINAL`) are listed. To inspect the current loop row, expand the parent table:
+> **Field symbols are supported via source-parse enrichment.** `FIELD-SYMBOLS <FS>` declarations are not returned by ADT's `getChildVariables` hierarchy, so `debug vars` fetches the current method's source, extracts all `FIELD-SYMBOLS <name>` declarations, and requests them directly via `getVariables`. Assigned field symbols appear in the variable list and can be expanded like any other variable:
 > ```bash
-> abapgit-agent debug vars --expand RT_DATA --json   # table rows visible by index
+> abapgit-agent debug vars --json                          # <LS> appears in the list
+> abapgit-agent debug vars --expand '<LS>' --json          # expand field symbol children
+> abapgit-agent debug vars --expand '<LS>'->NAME --json    # single field
 > ```
-> Alternatively, step over the assignment and use `--name` on a scalar component directly.
+> Unassigned field symbols will be returned with an empty or unset value.
 
 > **`step --type continue` return values:**
 > - `{"continued":true,"finished":true}` — program ran to **completion** (ADT returned HTTP 500, session is over). Do not re-attach.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.17.9",
+  "version": "1.18.1",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",
@@ -42,10 +42,13 @@
     "test:customize": "node tests/run-all.js --customize",
     "test:cmd:debug": "node tests/run-all.js --cmd --command=debug",
     "test:debug": "node tests/run-all.js --debug",
-    "test:debug:scenarios": "bash tests/integration/debug-scenarios.sh",
-    "test:debug:scenarios:1": "bash tests/integration/debug-scenarios.sh 1",
-    "test:debug:scenarios:2": "bash tests/integration/debug-scenarios.sh 2",
-    "test:debug:scenarios:3": "bash tests/integration/debug-scenarios.sh 3",
+    "test:debug:scripted": "node tests/run-all.js --debug-scripted",
+    "test:debug:scripted:3": "bash tests/integration/debug-scripted-scenarios.sh 3",
+    "test:debug:scripted:4": "bash tests/integration/debug-scripted-scenarios.sh 4",
+    "test:debug:scripted:5": "bash tests/integration/debug-scripted-scenarios.sh 5",
+    "test:debug:repl": "node tests/run-all.js --debug-repl",
+    "test:debug:repl:1": "bash tests/integration/debug-repl-scenarios.sh 1",
+    "test:debug:repl:2": "bash tests/integration/debug-repl-scenarios.sh 2",
     "test:cmd:upgrade": "node tests/run-all.js --cmd --command=upgrade",
     "test:lifecycle": "node tests/run-all.js --lifecycle",
     "test:pull": "node tests/run-all.js --pull",
@@ -56,13 +59,14 @@
     "unrelease": "node scripts/unrelease.js"
   },
   "dependencies": {
+    "axios": "^1.15.2",
     "dotenv": "^16.3.1",
     "node-fetch": "^2.7.0",
     "uuid": "^9.0.0",
     "winston": "^3.11.0"
   },
   "devDependencies": {
-    "jest": "^29.7.0",
+    "jest": "^30.3.0",
     "supertest": "^7.2.2"
   },
   "engines": {

package/src/commands/debug.js

@@ -19,8 +19,10 @@
  *   - Local state persisted in tmp so stateless CLI calls share the breakpoint list.
  *
  * Session management for AI/scripting mode (--json):
- *   attach --json spawns a background daemon (debug-daemon.js) that holds the
- *   stateful ADT HTTP connection open. step/vars/stack/terminate are thin IPC
+ *   attach --json runs the IPC socket server in-process after emitting the
+ *   session JSON line. This keeps the ADT TCP connection alive in the same
+ *   process that called attach() — SAP pins the debug session to the
+ *   originating TCP connection. step/vars/stack/terminate are thin IPC
  *   clients that connect to the daemon's Unix socket and exchange one JSON command
  *   per invocation. The daemon exits when terminate is called or after 30 min idle.
  *
@@ -30,7 +32,6 @@
 
 const net  = require('net');
 const path = require('path');
-const { spawn } = require('child_process');
 const { AdtHttp }      = require('../utils/adt-http');
 const { DebugSession } = require('../utils/debug-session');
 const debugStateModule = require('../utils/debug-state');
@@ -47,7 +48,13 @@ const _loadBpState = debugStateModule.loadBreakpointState;
 // Daemon socket path — may be absent in unit-test mocks
 const _getDaemonSocketPath = debugStateModule.getDaemonSocketPath;
 
-const ADT_CLIENT_ID = 'ABAPGIT-AGENT-CLI';
+// Allow callers to override the terminalId/ideId used for listener and
+// breakpoint registration via env var. This lets CI jobs use a unique ID
+// per run to avoid stale listeners from crashed previous runs blocking
+// the listener POST (SAP ICM returns 400 if another listener with the
+// same terminalId is still registered and DELETE is not available on the
+// system).
+const ADT_CLIENT_ID = process.env.ABAPGIT_DEBUG_TERMINAL_ID || 'ABAPGIT-AGENT-CLI';
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -632,8 +639,8 @@ async function cmdDelete(args, config, adt) {
 async function cmdAttach(args, config, adt) {
   const sessionIdOverride = val(args, '--session');
   const jsonOutput = hasFlag(args, '--json');
-  // Per-poll timeout in seconds sent to ADT (ADT blocks the POST for this long)
   const pollTimeout = parseInt(val(args, '--timeout') || '30', 10);
+  const maxListenSeconds = parseInt(val(args, '--max-listen') || '240', 10);
   // Shorter timeout used in takeover mode — keeps the connection alive but
   // lets ADT process stepContinue quickly and lets session 2 exit within
   // ~5 seconds of clearActiveSession being written.
@@ -646,8 +653,42 @@ async function cmdAttach(args, config, adt) {
     process.stderr.write('\n  Waiting for breakpoint hit... (run your ABAP program in a separate window)\n');
   }
 
+  // Fresh session for attach flow. Don't set stateful here — CSRF fetch
+  // without stateful avoids tying up a dialog WP. Stateful is added per-call
+  // by debug-session.js STATEFUL_HEADER on attach/getStack/step/vars.
+  adt.clearSession();
+  if (adt._axios) {
+    const agent = adt._axios.defaults.httpsAgent || adt._axios.defaults.httpAgent;
+    if (agent) agent.destroy();
+    if (adt._axios.defaults.httpsAgent) {
+      adt._axios.defaults.httpsAgent = new (require('https').Agent)({ rejectUnauthorized: false, keepAlive: true });
+    } else if (adt._axios.defaults.httpAgent) {
+      adt._axios.defaults.httpAgent = new (require('http').Agent)({ keepAlive: true });
+    }
+  }
   await adt.fetchCsrfToken();
 
+  // Delete any stale listener registered under our terminalId from a previous
+  // (possibly crashed) run.  A frozen ABAP work process holding a listener for
+  // the same terminalId causes SAP ICM to return HTTP 400 "Service cannot be
+  // reached" for every new listener POST.  Deleting first clears that state.
+  // Ignore errors — there may be no stale listener to delete.
+  if (!sessionIdOverride) {
+    try {
+      const delUrl = `/sap/bc/adt/debugger/listeners` +
+        `?debuggingMode=user` +
+        `&requestUser=${encodeURIComponent((config.user || '').toUpperCase())}` +
+        `&terminalId=${encodeURIComponent(ADT_CLIENT_ID)}` +
+        `&ideId=${encodeURIComponent(ADT_CLIENT_ID)}` +
+        `&checkConflict=false` +
+        `&notifyConflict=true`;
+      await adt.delete(delUrl);
+      if (jsonOutput) process.stderr.write(`[debug-attach] deleted stale listener\n`);
+    } catch (e) {
+      if (jsonOutput) process.stderr.write(`[debug-attach] delete listener (cleanup): ${e.statusCode || e.message}\n`);
+    }
+  }
+
   // Re-POST local breakpoints to refresh them on the server before listening.
   // Breakpoints expire when the SAP session or work process is restarted.
   // This ensures they are active regardless of when they were originally set.
@@ -672,6 +713,7 @@ async function cmdAttach(args, config, adt) {
   }
   let sessionId = sessionIdOverride;
   let positionResult = null;
+  let session = null;
 
   if (!sessionId) {
     // ADT listeners: POST long-polls until a breakpoint is hit (or timeout).
@@ -683,9 +725,9 @@ async function cmdAttach(args, config, adt) {
       `&terminalId=${encodeURIComponent(listenTerminalId)}` +
       `&ideId=${encodeURIComponent(listenTerminalId)}`;
 
-    const MAX_POLLS = Math.ceil(240 / pollTimeout); // up to 4 minutes total
+    const MAX_POLLS = Math.ceil(maxListenSeconds / pollTimeout);
     // In takeover mode we switch to takeoverPollTimeout — recalculate the limit then.
-    const MAX_TAKEOVER_POLLS = Math.ceil(240 / takeoverPollTimeout);
+    const MAX_TAKEOVER_POLLS = Math.ceil(maxListenSeconds / takeoverPollTimeout);
     let dots = 0;
     const attachStartedAt = Date.now(); // used to detect if another session takes over
     let takenOver = false;
@@ -723,6 +765,12 @@ async function cmdAttach(args, config, adt) {
           await new Promise(r => setTimeout(r, 2000));
           continue;
         }
+        if (err && err.statusCode === 400 &&
+            err.body && err.body.includes('Service cannot be reached')) {
+          if (jsonOutput) process.stderr.write(`[debug-attach] listener POST returned 400 (Service cannot be reached), retrying in 5s...\n`);
+          await new Promise(r => setTimeout(r, 5000));
+          continue;
+        }
         if (err && err.statusCode === 404) {
           console.error(
             '\n  Debug session commands require ADT Debugger service (listeners).' +
@@ -742,6 +790,7 @@ async function cmdAttach(args, config, adt) {
         const debuggeeIdMatch = resp.body.match(/<DEBUGGEE_ID>([^<]+)<\/DEBUGGEE_ID>/i) ||
                                 resp.body.match(/DEBUGGEE_ID="([^"]+)"/i);
         sessionId = debuggeeIdMatch ? debuggeeIdMatch[1].trim() : null;
+        if (jsonOutput && sessionId) process.stderr.write(`[debug-attach] listener returned debuggeeId=${sessionId}\n`);
 
         if (!sessionId) {
           // Fallback: some ADT versions put session info in different attributes
@@ -773,6 +822,34 @@ async function cmdAttach(args, config, adt) {
           }
           continue;
         }
+
+        // Attach to the WP and verify it's alive before committing.
+        // In --json mode: if the WP is a stale session from a previous run,
+        // attach() may succeed but getPosition() returns 400. When that happens,
+        // reset the SAP session fully and continue listening for a fresh BP hit.
+        {
+          if (!jsonOutput) process.stderr.write('\n  Attaching to debug session...\n');
+          const candidateSession = new DebugSession(adt, sessionId);
+          try {
+            await candidateSession.attach(sessionId, (config.user || '').toUpperCase());
+          } catch (e) {
+            if (jsonOutput) {
+              process.stderr.write(`[debug-attach] attach() failed: ${e.message || e} — resetting session\n`);
+              adt.clearSession();
+              await adt.fetchCsrfToken();
+              sessionId = null;
+              continue;
+            }
+            printHttpError(e, { prefix: '  Error during attach' });
+            if (e.body) console.error('  Response body:', e.body.substring(0, 400));
+            process.exit(1);
+          }
+          // attach() succeeded — skip getPosition() validation.
+          // With keepAlive, the connection is shared and getStack via the
+          // in-process daemon will use the same AdtHttp + same TCP socket.
+          positionResult = { position: {}, source: [] };
+          session = candidateSession;
+        }
         break;
       }
 
@@ -799,93 +876,53 @@ async function cmdAttach(args, config, adt) {
         if (!jsonOutput) process.stderr.write('  Listener timed out waiting for other session to finish.\n\n');
         process.exit(0);
       }
-      console.error('\n  Timeout: No breakpoint was hit within 4 minutes.\n');
+      console.error(`\n  Timeout: No breakpoint was hit within ${maxListenSeconds}s.\n`);
       process.exit(1);
     }
   }
 
-  const session = new DebugSession(adt, sessionId);
-
-  // If we got here via the listener (not --session override), we have a
-  // DEBUGGEE_ID and need to call ?method=attach to register as the active
-  // debugger for that work process. Without this step, all subsequent calls
-  // (getStack, getVariables, step) return "noSessionAttached" (T100-530).
-  if (!sessionIdOverride) {
-    if (!jsonOutput) {
-      process.stderr.write('\n  Attaching to debug session...\n');
-    }
+  // When using --session override (no listener), do attach+getPosition here.
+  if (sessionIdOverride) {
+    session = new DebugSession(adt, sessionId);
+    // getPosition is best-effort for --session override (e.g. human REPL recovery)
     try {
-      await session.attach(sessionId, (config.user || '').toUpperCase());
+      positionResult = await session.getPosition();
     } catch (e) {
-      printHttpError(e, { prefix: '  Error during attach' });
-      if (e.body) console.error('  Response body:', e.body.substring(0, 400));
-      process.exit(1);
+      positionResult = { position: {}, source: [] };
     }
   }
 
-  // Fetch position + variables now that we have a live session
-  try {
-    positionResult = await session.getPosition();
-  } catch (e) {
-    // Position fetch is best-effort; proceed with empty state
-    positionResult = { position: {}, source: [] };
-  }
-
-  // Dummy loop body retained for structural compatibility (never executes)
-  if (false) {
-    const MAX_POLLS = 0;
-    const POLL_INTERVAL = 0;
-    for (let i = 0; i < MAX_POLLS; i++) {
-      try {
-        const frames = await session.getStack();
-        if (frames && frames.length > 0 && frames[0].line > 0) {
-          positionResult = await session.getPosition();
-          break;
-        }
-      } catch (e) {
-        // Stack not ready yet — keep polling
-      }
-      await new Promise(r => setTimeout(r, POLL_INTERVAL));
-    }
+  // session and positionResult are now set (either via listener loop or --session override)
+  if (!session) {
+    // Should not reach here — listener loop either sets session or exits
+    console.error('\n  Internal error: session not initialized after attach.\n');
+    process.exit(1);
   }
+  if (!positionResult) positionResult = { position: {}, source: [] };
 
   const { position, source } = positionResult;
   saveActiveSession(config, { sessionId, position });
 
   if (jsonOutput) {
-    // Spawn the background daemon to hold the stateful ADT HTTP connection.
-    // The daemon process inherits the exact SAP_SESSIONID cookie + CSRF token
-    // via the snapshot env var, so it reuses the same ABAP work process.
+    // Run the socket server in-process so all ADT requests reuse the same TCP
+    // connection that called attach(). SAP pins the debug session to the
+    // originating TCP connection — a new connection returns HTTP 400.
     const socketPath = _getDaemonSocketPath ? _getDaemonSocketPath(config) : null;
     if (socketPath) {
-      const snapshot = { csrfToken: adt.csrfToken, cookies: adt.cookies };
-      const daemonEnv = {
-        ...process.env,
-        DEBUG_DAEMON_MODE:            '1',
-        DEBUG_DAEMON_CONFIG:          JSON.stringify(config),
-        DEBUG_DAEMON_SESSION_ID:      sessionId,
-        DEBUG_DAEMON_SOCK_PATH:       socketPath,
-        DEBUG_DAEMON_SESSION_SNAPSHOT: JSON.stringify(snapshot)
-      };
-      const daemonScript = path.resolve(__dirname, '../utils/debug-daemon.js');
-      const child = spawn(process.execPath, [daemonScript], {
-        detached: true,
-        stdio: ['ignore', 'ignore', 'ignore'],
-        env: daemonEnv
-      });
-      child.unref();
-
-      // Wait for daemon socket to appear (up to 5 s) before returning JSON
-      try {
-        await waitForSocket(socketPath, 5000);
-        // Persist socket path in session state so step/vars/stack/terminate find it
-        saveActiveSession(config, { sessionId, position, socketPath });
-      } catch (e) {
-        // Non-fatal: fall back to stateless direct-ADT mode
-      }
+      // Save cookies so terminate can release the frozen WP even if the daemon is gone
+      saveActiveSession(config, { sessionId, position, socketPath, cookies: adt.cookies });
     }
 
+    // Emit session JSON now so the caller (script / AI) knows the BP was hit.
     console.log(JSON.stringify({ session: sessionId, position, source }));
+
+    if (socketPath) {
+      const { startDaemon } = require('../utils/debug-daemon');
+      // Blocks until terminate is called or idle timeout — intentional.
+      // The process stays alive as the IPC socket server, holding the ADT
+      // TCP connection open. The caller runs this command in the background (&).
+      await startDaemon(session, socketPath);
+    }
     return;
   }
 
@@ -1050,8 +1087,8 @@ async function cmdVars(args, config, adt) {
  *   LO_FACTORY->MT_COMMAND_MAP   (object attr → table)
  *   LS_DATA->COMPONENT            (structure field)
  *
- * When a daemon socket is active, uses daemon IPC for single-segment paths.
- * Multi-segment paths always run directly against ADT (DebugSession.expandPath).
+ * When a daemon socket is active, uses daemon IPC for both single-segment and
+ * multi-segment paths so the stateful ADT session is always reused.
  */
 async function cmdExpand(expandName, sessionId, socketPath, config, adt, jsonOutput) {
   // Split on -> to detect path notation. Also handle --> typos by stripping stray dashes.
@@ -1059,20 +1096,37 @@ async function cmdExpand(expandName, sessionId, socketPath, config, adt, jsonOut
   //   [N]-FIELD  → [N]->FIELD   (array row then struct field)
   //   *-FIELD    → *->FIELD     (dereference then struct field: lr_request->*-files)
   const normalizedName = expandName
+    .replace(/^([A-Za-z0-9_@]+)\[(\d+)\]$/, '$1->[$2]') // VAR[N]       → VAR->[N]   (exact match)
+    .replace(/([A-Za-z0-9_@]+)\[(\d+)\]->/g, '$1->[$2]->') // VAR[N]->X → VAR->[N]->X (mid-path)
     .replace(/\](-(?!>))/g,  ']->') // [N]-FIELD → [N]->FIELD
     .replace(/\*(-(?!>))/g,  '*->'); // *-FIELD   → *->FIELD
   const pathParts = normalizedName.split('->').map(s => s.replace(/^-+|-+$/g, '').trim()).filter(Boolean);
 
-  // Multi-segment path: must go direct (daemon IPC only handles one level at a time)
+  // Multi-segment path: route through daemon when available (daemon holds stateful ADT session)
   if (pathParts.length > 1) {
-    if (!adt.csrfToken) await adt.fetchCsrfToken();
-    const session = new DebugSession(adt, sessionId);
     let result;
-    try {
-      result = await session.expandPath(pathParts);
-    } catch (err) {
-      printHttpError(err, { prefix: '  Error' });
-      process.exit(1);
+    if (socketPath) {
+      let resp;
+      try {
+        resp = await sendDaemonCommand(socketPath, { cmd: 'expandPath', pathParts }, 60000);
+      } catch (err) {
+        printHttpError(err, { prefix: '  Error' });
+        process.exit(1);
+      }
+      if (!resp.ok) {
+        console.error(`\n  Error: ${resp.error}\n`);
+        process.exit(1);
+      }
+      result = { variable: resp.variable, children: resp.children };
+    } else {
+      if (!adt.csrfToken) await adt.fetchCsrfToken();
+      const session = new DebugSession(adt, sessionId);
+      try {
+        result = await session.expandPath(pathParts);
+      } catch (err) {
+        printHttpError(err, { prefix: '  Error' });
+        process.exit(1);
+      }
     }
     const { variable: target, children } = result;
     return _printExpandResult(expandName, target, children, jsonOutput);
@@ -1243,20 +1297,29 @@ async function cmdTerminate(args, config, adt) {
 
   // Prefer daemon IPC — daemon calls session.terminate() then exits itself
   if (socketPath) {
-    let resp;
+    let ipcSucceeded = false;
     try {
-      resp = await sendDaemonCommand(socketPath, { cmd: 'terminate' }, 30000);
+      const resp = await sendDaemonCommand(socketPath, { cmd: 'terminate' }, 30000);
+      if (resp && resp.ok) ipcSucceeded = true;
     } catch (err) {
-      // Socket may be gone already (daemon crashed or timed out) — treat as terminated
-      resp = { ok: true, terminated: true };
+      // Socket is gone (daemon crashed or was killed) — fall through to direct ADT call
     }
-    clearActiveSession(config);
-    if (jsonOutput) {
-      console.log(JSON.stringify({ terminated: resp.ok ? true : resp.error }));
+    if (ipcSucceeded) {
+      clearActiveSession(config);
+      if (jsonOutput) {
+        console.log(JSON.stringify({ terminated: true }));
+        return;
+      }
+      console.log('\n  Debug session terminated.\n');
       return;
     }
-    console.log('\n  Debug session terminated.\n');
-    return;
+    // IPC failed — daemon is gone but ABAP WP may still be frozen.
+    // Use stored session cookies to release the WP via direct ADT call.
+    const savedState = loadActiveSession(config);
+    if (savedState && savedState.cookies && sessionId) {
+      adt.cookies = savedState.cookies;
+    }
+    // Fall through to direct ADT terminate below
   }
 
   // Fallback: direct ADT call
@@ -1289,32 +1352,6 @@ async function cmdTerminate(args, config, adt) {
 
 // ─── Daemon IPC helpers ───────────────────────────────────────────────────────
 
-/**
- * Wait for the daemon's Unix socket to appear (after spawn).
- * @param {string} socketPath
- * @param {number} timeoutMs
- */
-function waitForSocket(socketPath, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const deadline = Date.now() + timeoutMs;
-    function check() {
-      const client = net.createConnection(socketPath);
-      client.on('connect', () => {
-        client.destroy();
-        resolve();
-      });
-      client.on('error', () => {
-        if (Date.now() >= deadline) {
-          reject(new Error('Timeout waiting for debug daemon to start'));
-        } else {
-          setTimeout(check, 100);
-        }
-      });
-    }
-    check();
-  });
-}
-
 /**
  * Send one JSON command to the daemon and return the parsed JSON response.
  * @param {string} socketPath

package/src/commands/inspect.js

@@ -285,7 +285,7 @@ Examples:
       process.exit(1);
     }
 
-    const filesSyntaxCheck = args[filesArgIndex + 1].split(',').map(f => f.trim());
+    let filesSyntaxCheck = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
     // Parse optional --variant parameter; fall back to project config
     const variantArgIndex = args.indexOf('--variant');
@@ -293,6 +293,31 @@ Examples:
     const inspectConfig = getInspectConfig();
     const variant = variantArg || inspectConfig.variant || null;
 
+    // Filter out files matching inspect.exclude patterns from project config
+    const excludePatterns = inspectConfig.exclude || [];
+    if (excludePatterns.length > 0) {
+      const before = filesSyntaxCheck.length;
+      filesSyntaxCheck = filesSyntaxCheck.filter(f => {
+        const objName = pathModule.basename(f).split('.')[0].toUpperCase();
+        return !excludePatterns.some(pattern => {
+          const re = new RegExp('^' + pattern.toUpperCase().replace(/\*/g, '.*') + '$');
+          return re.test(objName);
+        });
+      });
+      const skipped = before - filesSyntaxCheck.length;
+      if (skipped > 0 && !args.includes('--json')) {
+        console.log(`  Skipped ${skipped} file(s) excluded by inspect config`);
+      }
+      if (filesSyntaxCheck.length === 0) {
+        if (args.includes('--json')) {
+          console.log(JSON.stringify([]));
+        } else {
+          console.log('\n  All files excluded by inspect config — nothing to check.\n');
+        }
+        return;
+      }
+    }
+
     // Parse optional --junit-output parameter
     const junitArgIndex = args.indexOf('--junit-output');
     const junitOutput = junitArgIndex !== -1 ? args[junitArgIndex + 1] : null;
@@ -316,6 +341,51 @@ Examples:
     // Send all files in one request
     const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config, variant, http, verbose);
 
+    // Apply inspect.suppress rules — downgrade matching errors/warnings to infos
+    const suppressRules = inspectConfig.suppress || [];
+    if (suppressRules.length > 0) {
+      for (const result of results) {
+        const objName = (result.OBJECT_NAME || result.object_name || '').toUpperCase();
+        for (const rule of suppressRules) {
+          const objPattern = new RegExp('^' + (rule.object || '*').toUpperCase().replace(/\*/g, '.*') + '$');
+          if (!objPattern.test(objName)) continue;
+          const msgPattern = new RegExp((rule.message || '*').replace(/\*/g, '.*'), 'i');
+
+          // Downgrade matching errors → infos
+          const errors = result.ERRORS || result.errors || [];
+          const kept = [];
+          for (const err of errors) {
+            const text = err.TEXT || err.text || '';
+            if (msgPattern.test(text)) {
+              const infos = result.INFOS || result.infos || [];
+              infos.push({ ...err, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
+              if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
+              const ec = result.ERROR_COUNT !== undefined ? 'ERROR_COUNT' : 'error_count';
+              result[ec] = Math.max(0, (result[ec] || 0) - 1);
+            } else {
+              kept.push(err);
+            }
+          }
+          if (result.ERRORS !== undefined) result.ERRORS = kept; else result.errors = kept;
+
+          // Downgrade matching warnings → infos
+          const warnings = result.WARNINGS || result.warnings || [];
+          const keptW = [];
+          for (const warn of warnings) {
+            const text = warn.MESSAGE || warn.message || '';
+            if (msgPattern.test(text)) {
+              const infos = result.INFOS || result.infos || [];
+              infos.push({ ...warn, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
+              if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
+            } else {
+              keptW.push(warn);
+            }
+          }
+          if (result.WARNINGS !== undefined) result.WARNINGS = keptW; else result.warnings = keptW;
+        }
+      }
+    }
+
     // JUnit output mode — write XML file, then continue to normal output
     if (junitOutput) {
       const xml = buildInspectJUnit(results);

package/src/commands/pull.js

@@ -329,7 +329,8 @@ Examples:
       const jobId = result.JOB_ID || result.job_id;
       const message = result.MESSAGE || result.message;
       const errorDetail = result.ERROR_DETAIL || result.error_detail;
-      const activatedCount = result.ACTIVATED_COUNT || result.activated_count || 0;
+      const activatedCountRaw = result.ACTIVATED_COUNT ?? result.activated_count ?? null;
+      const activatedCount = activatedCountRaw || 0;
       const failedCount = result.FAILED_COUNT || result.failed_count || 0;
       const logMessages = result.LOG_MESSAGES || result.log_messages || [];
       const activatedObjects = result.ACTIVATED_OBJECTS || result.activated_objects || [];
@@ -362,7 +363,7 @@ Examples:
       if (success === 'X' || success === true) {
         console.log(`✅ Pull completed successfully!`);
         console.log(`   Message: ${message || 'N/A'}`);
-        if (activatedCount === 0 && files && !isRepull) {
+        if (activatedCountRaw !== null && activatedCount === 0 && activatedObjects.length === 0 && files && !isRepull) {
           console.warn(`⚠️  ACTIVATED_COUNT: 0 — no objects were activated. Check for unpushed commits: git log origin/<branch>..HEAD`);
         }
       } else if (failedCount === 0 && failedObjects.length === 0 &&

package/src/commands/view.js

@@ -151,7 +151,7 @@ async function computeGlobalStarts(objName, sections, config) {
  * Returns 0 if no better line is found (falls back to METHOD statement).
  */
 function findFirstExecutableLine(lines) {
-  const declPattern = /^\s*(data|final|types|constants|class-data)[\s:(]/i;
+  const declPattern = /^\s*(data|final|types|constants|class-data|field-symbols)[\s:(</\[]/i;
   const methodPattern = /^\s*method\s+/i;
   const commentPattern = /^\s*[*"]/;
   // Program-level header/declaration keywords that are not executable statements

package/src/config.js

@@ -255,6 +255,8 @@ function getInspectConfig() {
   const projectConfig = loadProjectConfig();
   return {
     variant: projectConfig?.inspect?.variant || null,
+    exclude: projectConfig?.inspect?.exclude || [],
+    suppress: projectConfig?.inspect?.suppress || [],
   };
 }