abapgit-agent 1.10.1 → 1.11.0

package/abap/CLAUDE.md

@@ -308,32 +308,26 @@ abapgit-agent debug list    # confirm it was registered
 
 **Step 2 — attach and trigger**
 
-Two modes depending on context:
+Best practice: individual sequential calls. Once the daemon is running and
+the session is saved to the state file, each `vars/stack/step` command is a
+plain standalone call — no `--session` flag needed.
 
-*Interactive (human in a terminal):*
 ```bash
-# Terminal 1 — attach (blocks waiting for breakpoint, opens REPL on hit)
-abapgit-agent debug attach
-
-# Terminal 2 — trigger (any command that calls the backend)
-abapgit-agent unit --files src/zcl_my_class.clas.testclasses.abap
-abapgit-agent inspect --files src/zcl_my_class.clas.abap
-```
-
-*Scripted (AI / automation) — best practice: individual sequential calls:*
-
-Once the daemon is running and the session is saved to the state file, each
-`vars/stack/step` command is a plain standalone call — no bash script needed.
-
-```bash
-# Step 1: start attach listener in background (spawns a daemon, saves session to state file)
+# Start attach listener in background (spawns a daemon, saves session to state file)
 abapgit-agent debug attach --json > /tmp/attach.json 2>&1 &
-sleep 2
 
-# Step 2: trigger in background — MUST stay alive for the whole session
+# Rule 1: wait for "Listener active" in the output, THEN fire the trigger.
+# attach --json prints "Listener active" to stderr (captured in attach.json) the
+# moment the long-poll POST is about to be sent to ADT.  Waiting for this marker
+# is reliable under any system load; a blind sleep may fire the trigger before
+# ADT has a registered listener, causing the breakpoint hit to be missed.
+until grep -q "Listener active" /tmp/attach.json 2>/dev/null; do sleep 0.3; done
+sleep 1   # brief extra window for the POST to reach ADT
+
+# Trigger in background — MUST stay alive for the whole session
 abapgit-agent unit --files src/zcl_my_class.clas.testclasses.abap > /tmp/trigger.json 2>&1 &
 
-# Step 3: poll until breakpoint fires and session JSON appears in attach output
+# Poll until breakpoint fires and session JSON appears in attach output
 SESSION=""
 for i in $(seq 1 30); do
   sleep 0.5
@@ -341,40 +335,29 @@ for i in $(seq 1 30); do
   [ -n "$SESSION" ] && break
 done
 
-# Step 4: inspect and step — each is an individual call, no --session needed
+# Inspect and step — each is an individual call, no --session needed
 abapgit-agent debug stack --json
 abapgit-agent debug vars  --json
 abapgit-agent debug vars  --expand LS_OBJECT --json
 abapgit-agent debug step  --type over --json
 abapgit-agent debug vars  --json
 
-# Step 5: ALWAYS release the ABAP work process before finishing
+# ALWAYS release the ABAP work process before finishing
 abapgit-agent debug step --type continue --json
 
-# Step 6: check trigger result
+# Check trigger result
 cat /tmp/trigger.json
 rm -f /tmp/attach.json /tmp/trigger.json
 ```
 
 > **Four rules for scripted mode:**
-> 1. `sleep 2` after starting attach — the listener must register on the server before the trigger fires
+> 1. Wait for `"Listener active"` in the attach output before firing the trigger — this message is printed to stderr (captured in `attach.json`) the moment the listener POST is about to reach ADT. A blind `sleep` is not reliable under system load.
 > 2. Keep the trigger process alive in the background for the entire session — if it exits, the ABAP work process is released and the session ends
 > 3. Always finish with `step --type continue` — this releases the frozen work process so the trigger can complete normally
 > 4. **Never pass `--session` to `step/vars/stack`** — it bypasses the daemon IPC and causes `noSessionAttached`. Omit it and let commands auto-load from the saved state file.
 
 **Step 3 — step through and inspect**
 
-*Interactive REPL commands (after `attach` without `--json`):*
-```
-  debug> v          — show all variables
-  debug> x LT_DATA  — expand a table or structure
-  debug> n          — step over
-  debug> s          — step into
-  debug> bt         — call stack
-  debug> q          — detach (program continues); kill — hard abort
-```
-
-*Scripted commands (after `attach --json`) — omit `--session`, commands auto-load from state file:*
 ```bash
 abapgit-agent debug vars   --json                        # all variables
 abapgit-agent debug vars   --name LV_RESULT --json       # one variable
@@ -396,6 +379,24 @@ abapgit-agent debug delete --all
 
 This project's workflow mode is configured in `.abapGitAgent` under `workflow.mode`.
 
+### Project-Level Config (`.abapgit-agent.json`)
+
+Checked into the repository — applies to all developers. **Read this file at the start of every session.**
+
+| Setting | Values | Default | Effect |
+|---------|--------|---------|--------|
+| `safeguards.requireFilesForPull` | `true`/`false` | `false` | Requires `--files` on every pull |
+| `safeguards.disablePull` | `true`/`false` | `false` | Disables pull entirely (CI/CD-only projects) |
+| `conflictDetection.mode` | `"abort"`/`"ignore"` | `"abort"` | Whether to abort pull on conflict |
+| `transports.hook.path` | string | `null` | Path to JS module that auto-selects a transport for pull |
+| `transports.hook.description` | string | `null` | Optional label shown when the hook runs |
+| `transports.allowCreate` | `true`/`false` | `true` | When `false`, `transport create` is blocked |
+| `transports.allowRelease` | `true`/`false` | `true` | When `false`, `transport release` is blocked |
+
+CLI `--conflict-mode` always overrides the project config for a single run.
+
+See **AI Tool Guidelines** below for how to react to each setting.
+
 ### Workflow Modes
 
 | Mode | Branch Strategy | Rebase Before Pull | Create PR |
@@ -571,6 +572,37 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 3. ✓ `git pull origin <default>` before push
 4. ✗ Don't create feature branches
 
+**Read `.abapgit-agent.json` to determine project safeguards and conflict detection:**
+
+**When `safeguards.requireFilesForPull = true`:**
+1. ✓ Always include `--files` in every `pull` command
+2. ✓ Never run `abapgit-agent pull` without `--files`
+3. ✗ Don't suggest or run a full pull without specifying files
+
+**When `safeguards.requireFilesForPull = false` or not set:**
+1. ✓ `--files` is optional — use it for speed, omit for full pull
+
+**When `safeguards.disablePull = true`:**
+1. ✗ Do not run `abapgit-agent pull` at all
+2. ✓ Inform the user that pull is disabled for this project (CI/CD only)
+
+**When `conflictDetection.mode = "ignore"` or not set:**
+1. ✓ Run `pull` normally — no conflict flags needed
+2. ✗ Don't add `--conflict-mode` unless user explicitly asks
+
+**When `conflictDetection.mode = "abort"`:**
+1. ✓ Conflict detection is active — pull aborts if ABAP system was edited since last pull
+2. ✓ If pull is aborted with conflict error, inform user and suggest `--conflict-mode ignore` to override for that run
+3. ✗ Don't silently add `--conflict-mode ignore` — always tell the user about the conflict
+
+**When `transports.allowCreate = false`:**
+1. ✗ Do not run `abapgit-agent transport create`
+2. ✓ Inform the user that transport creation is disabled for this project
+
+**When `transports.allowRelease = false`:**
+1. ✗ Do not run `abapgit-agent transport release`
+2. ✓ Inform the user that transport release is disabled for this project
+
 ---
 
 ## Development Workflow (Detailed)
@@ -600,6 +632,7 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
        │
        ▼
 6. Activate → abapgit-agent pull --files src/file.clas.abap
+       │         (behaviour depends on .abapgit-agent.json — see AI Tool Guidelines)
        │
        ▼
 7. Verify → Check pull output
@@ -791,6 +824,9 @@ abapgit-agent syntax --files src/zcl_class1.clas.abap,src/zif_intf1.intf.abap,sr
 # 2. Pull/activate AFTER pushing to git
 abapgit-agent pull --files src/zcl_class1.clas.abap,src/zcl_class2.clas.abap
 
+# Override conflict detection for a single pull (e.g. deliberate branch switch)
+abapgit-agent pull --files src/zcl_class1.clas.abap --conflict-mode ignore
+
 # 3. Inspect AFTER pull (for errors or unsupported types)
 abapgit-agent inspect --files src/zcl_class1.clas.abap
 

package/bin/abapgit-agent

@@ -24,7 +24,7 @@ const gitUtils = require('../src/utils/git-utils');
 const versionCheck = require('../src/utils/version-check');
 const validators = require('../src/utils/validators');
 const { AbapHttp } = require('../src/utils/abap-http');
-const { loadConfig, getTransport, isAbapIntegrationEnabled, getSafeguards } = require('../src/config');
+const { loadConfig, getTransport, isAbapIntegrationEnabled, getSafeguards, getConflictSettings, getTransportSettings } = require('../src/config');
 
 // Get terminal width for responsive table
 const getTermWidth = () => process.stdout.columns || 80;
@@ -55,7 +55,8 @@ async function main() {
     ref: require('../src/commands/ref'),
     init: require('../src/commands/init'),
     pull: require('../src/commands/pull'),
-    upgrade: require('../src/commands/upgrade')
+    upgrade: require('../src/commands/upgrade'),
+    transport: require('../src/commands/transport')
   };
 
   // Check if this is a modular command
@@ -102,7 +103,9 @@ To enable integration:
       loadConfig,
       AbapHttp,
       getTransport,
-      getSafeguards
+      getSafeguards,
+      getConflictSettings,
+      getTransportSettings
     };
 
     // Execute command
@@ -124,7 +127,7 @@ To enable integration:
 main().catch((err) => {
   // Known CLI errors (e.g. pull conflict) already printed their own output — skip re-printing.
   // For all other unexpected errors, print the message without the stack trace.
-  if (!err._isPullError) {
+  if (!err._isPullError && !err._isTransportError) {
     console.error(err.message || err);
   }
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -42,6 +42,7 @@
     "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",
+    "test:full-pull": "node tests/run-all.js --full-pull",
     "test:conflict": "node tests/run-all.js --conflict",
     "pull": "node bin/abapgit-agent",
     "release": "node scripts/release.js",

package/src/commands/debug.js

@@ -583,7 +583,7 @@ async function cmdAttach(args, config, adt) {
     let firstPoll = true;
 
     for (let i = 0; i < (takenOver ? MAX_TAKEOVER_POLLS : MAX_POLLS); i++) {
-      if (firstPoll && !jsonOutput) {
+      if (firstPoll) {
         process.stderr.write('  Listener active — trigger your ABAP program now.\n');
         firstPoll = false;
       }

package/src/commands/pull.js

@@ -9,7 +9,7 @@ module.exports = {
   requiresVersionCheck: true,
 
   async execute(args, context) {
-    const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards } = context;
+    const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards, getConflictSettings, getTransportSettings } = context;
 
     // Check project-level safeguards
     const safeguards = getSafeguards();
@@ -36,9 +36,9 @@ module.exports = {
     let gitUrl = urlArgIndex !== -1 ? args[urlArgIndex + 1] : null;
     let branch = branchArgIndex !== -1 ? args[branchArgIndex + 1] : gitUtils.getBranch();
     let files = null;
-    let conflictMode = conflictModeArgIndex !== -1 ? args[conflictModeArgIndex + 1] : 'abort';
+    let conflictMode = conflictModeArgIndex !== -1 ? args[conflictModeArgIndex + 1] : getConflictSettings().mode;
 
-    // Transport: CLI arg takes priority, then config/environment, then null
+    // Transport: CLI arg takes priority, then config/environment, then selector
     let transportRequest = null;
     if (transportArgIndex !== -1 && transportArgIndex + 1 < args.length) {
       // Explicit --transport argument
@@ -48,8 +48,39 @@ module.exports = {
       transportRequest = getTransport();
     }
 
+    // Auto-detect URL early (needed for transport_required check)
+    if (!gitUrl) {
+      gitUrl = gitUtils.getRemoteUrl();
+      if (!gitUrl) {
+        console.error('Error: Not in a git repository or no remote configured.');
+        console.error('Either run from a git repo, or specify --url <git-url>');
+        process.exit(1);
+      }
+      if (!jsonOutput) {
+        console.log(`📌 Auto-detected git remote: ${gitUrl}`);
+      }
+    }
+
     if (filesArgIndex !== -1 && filesArgIndex + 1 < args.length) {
       files = args[filesArgIndex + 1].split(',').map(f => f.trim());
+
+      // Validate that every file has a recognised ABAP source extension
+      // (.abap or .asddls) — XML metadata files must NOT be passed here
+      const ABAP_SOURCE_EXTS = new Set(['abap', 'asddls']);
+      const nonSourceFiles = files.filter(f => {
+        const base = f.split('/').pop(); // strip directory
+        const parts = base.split('.');
+        const ext = parts[parts.length - 1].toLowerCase();
+        return parts.length < 3 || !ABAP_SOURCE_EXTS.has(ext);
+      });
+      if (nonSourceFiles.length > 0) {
+        console.error('❌ Error: --files only accepts ABAP source files (.abap, .asddls).');
+        console.error('   The following file(s) are not ABAP source files:');
+        nonSourceFiles.forEach(f => console.error(`     ${f}`));
+        console.error('   Tip: pass the source file, not the XML metadata file.');
+        console.error('   Example: --files src/zcl_my_class.clas.abap');
+        process.exit(1);
+      }
     }
 
     // SAFEGUARD 2: Check if files are required but not provided
@@ -64,15 +95,52 @@ module.exports = {
       process.exit(1);
     }
 
-    if (!gitUrl) {
-      gitUrl = gitUtils.getRemoteUrl();
-      if (!gitUrl) {
-        console.error('Error: Not in a git repository or no remote configured.');
-        console.error('Either run from a git repo, or specify --url <git-url>');
-        process.exit(1);
+    // Auto-select transport when none configured and not in JSON mode
+    if (!transportRequest && !jsonOutput) {
+      const { selectTransport, isNonInteractive, _getTransportHookConfig } = require('../utils/transport-selector');
+
+      // Check if this package requires a transport before showing the interactive
+      // picker. Skip the status round-trip in non-interactive mode — selectTransport
+      // already returns null there without prompting, so the extra HTTP call is wasted.
+      let transportRequired = true; // Safe default: assume transport needed
+      if (!isNonInteractive()) {
+        try {
+          const config = loadConfig();
+          const http = new AbapHttp(config);
+          const csrfToken = await http.fetchCsrfToken();
+          const statusResult = await http.post('/sap/bc/z_abapgit_agent/status', { url: gitUrl }, { csrfToken });
+          if (statusResult.transport_required === false || statusResult.transport_required === 'false') {
+            transportRequired = false;
+          }
+        } catch (e) {
+          // Status check failed — proceed with selector as safe default
+        }
       }
-      if (!jsonOutput) {
-        console.log(`📌 Auto-detected git remote: ${gitUrl}`);
+
+      if (transportRequired) {
+        const config = loadConfig();
+        const http = new AbapHttp(config);
+        transportRequest = await selectTransport(config, http, loadConfig, AbapHttp, getTransportSettings);
+
+        // If a hook was configured but returned no transport, handle based on context
+        if (transportRequest === null) {
+          const hookConfig = _getTransportHookConfig();
+          if (hookConfig && hookConfig.hook) {
+            if (isNonInteractive()) {
+              // Non-interactive (AI/CI): fail — a configured hook must return a transport
+              console.error('❌ Error: transport hook returned no transport request.');
+              console.error(`   Hook: ${hookConfig.hook}`);
+              if (hookConfig.description) console.error(`   ${hookConfig.description}`);
+              process.exit(1);
+            } else {
+              // Interactive (TTY): warn and fall through to the picker
+              process.stderr.write(`⚠️  Transport hook returned no transport request (${hookConfig.hook}).\n`);
+              process.stderr.write('   Please select one manually:\n');
+              const { interactivePicker } = require('../utils/transport-selector');
+              transportRequest = await interactivePicker(http);
+            }
+          }
+        }
       }
     }
 

package/src/commands/status.js

@@ -32,7 +32,9 @@ module.exports = {
             console.log('   Repository: ✅ Created');
             const pkg = result.package || result.PACKAGE || 'N/A';
             const key = result.key || result.KEY || result.REPO_KEY || result.repo_key || 'N/A';
+            const transportRequired = result.transport_required === true || result.transport_required === 'true';
             console.log(`      Package: ${pkg}`);
+            console.log(`      Transport required: ${transportRequired ? 'Yes' : 'No'}`);
             console.log(`      URL: ${repoUrl}`);
             console.log(`      Key: ${key}`);
           } else {

package/src/commands/transport.js

@@ -0,0 +1,290 @@
+/**
+ * Transport command - List and manage SAP transport requests
+ */
+
+const VALID_SCOPES = ['mine', 'task', 'all'];
+const VALID_SUBCOMMANDS = ['list', 'create', 'check', 'release'];
+const VALID_TYPES = ['workbench', 'customizing'];
+
+module.exports = {
+  name: 'transport',
+  description: 'List and manage SAP transport requests',
+  requiresAbapConfig: true,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, getTransportSettings } = context;
+
+    const jsonOutput = args.includes('--json');
+
+    // Determine subcommand (first positional arg, default to 'list')
+    const subcommand = args[0] && !args[0].startsWith('-') ? args[0] : 'list';
+
+    if (!VALID_SUBCOMMANDS.includes(subcommand)) {
+      console.error(`❌ Error: Unknown subcommand '${subcommand}'. Use: ${VALID_SUBCOMMANDS.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Check project-level transport settings
+    const transportSettings = getTransportSettings();
+
+    if (subcommand === 'create' && !transportSettings.allowCreate) {
+      console.error(`❌ transport create is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport create disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    if (subcommand === 'release' && !transportSettings.allowRelease) {
+      console.error(`❌ transport release is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport release disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+
+    try {
+      switch (subcommand) {
+        case 'list':
+          await this._list(args, http, jsonOutput);
+          break;
+        case 'create':
+          await this._create(args, http, jsonOutput);
+          break;
+        case 'check':
+          await this._check(args, http, jsonOutput);
+          break;
+        case 'release':
+          await this._release(args, http, jsonOutput);
+          break;
+      }
+    } catch (error) {
+      console.error(`❌ Error: ${error.message}`);
+      process.exit(1);
+    }
+  },
+
+  async _list(args, http, jsonOutput) {
+    const scopeIdx = args.indexOf('--scope');
+    const scope = scopeIdx !== -1 ? args[scopeIdx + 1] : 'mine';
+
+    if (!VALID_SCOPES.includes(scope)) {
+      console.error(`❌ Error: Invalid scope '${scope}'. Valid values: ${VALID_SCOPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    const result = await http.get(`/sap/bc/z_abapgit_agent/transport?scope=${scope}`);
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const transports = result.TRANSPORTS || result.transports || [];
+    const scopeLabel = { mine: 'mine', task: 'task — where I own or have a task', all: 'all' }[scope];
+
+    console.log(`\n📋 Open Transport Requests (${scopeLabel})\n`);
+
+    if (transports.length === 0) {
+      console.log('  No open transport requests found.');
+      console.log('');
+      console.log('  To create one: abapgit-agent transport create');
+      console.log('  To see more:   abapgit-agent transport list --scope task');
+      return;
+    }
+
+    // Table header
+    const numW = 2;
+    const trW = 12;
+    const descW = 33;
+    const ownerW = 12;
+    const dateW = 10;
+
+    const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+    const header = `  ${'#'.padEnd(numW)}  ${pad('Number', trW)}  ${pad('Description', descW)}  ${pad('Owner', ownerW)}  ${'Date'}`;
+    const divider = `  ${'─'.repeat(numW)}  ${'─'.repeat(trW)}  ${'─'.repeat(descW)}  ${'─'.repeat(ownerW)}  ${'─'.repeat(dateW)}`;
+
+    console.log(header);
+    console.log(divider);
+
+    transports.forEach((t, i) => {
+      const num = t.NUMBER || t.number || '';
+      const desc = t.DESCRIPTION || t.description || '';
+      const owner = t.OWNER || t.owner || '';
+      const date = t.DATE || t.date || '';
+      console.log(`  ${String(i + 1).padEnd(numW)}  ${pad(num, trW)}  ${pad(desc, descW)}  ${pad(owner, ownerW)}  ${date}`);
+    });
+
+    console.log('');
+    console.log(`  ${transports.length} transport(s) found.`);
+    console.log('');
+    console.log(`  To use one: abapgit-agent pull --transport ${(transports[0].NUMBER || transports[0].number || 'DEVK900001')}`);
+
+    if (scope === 'mine') {
+      console.log('  To switch scope:');
+      console.log('    transport list --scope task   transports where I have a task');
+      console.log('    transport list --scope all     all open transports');
+    }
+  },
+
+  async _create(args, http, jsonOutput) {
+    const descIdx = args.indexOf('--description');
+    let description = descIdx !== -1 ? args[descIdx + 1] : null;
+
+    const typeIdx = args.indexOf('--type');
+    const type = typeIdx !== -1 ? args[typeIdx + 1] : 'workbench';
+
+    if (!VALID_TYPES.includes(type)) {
+      console.error(`❌ Error: Invalid type '${type}'. Valid values: ${VALID_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Prompt for description if not provided and running in TTY
+    if (!description && !jsonOutput && process.stdin.isTTY) {
+      description = await this._prompt('Description: ');
+    }
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CREATE', description: description || '', type },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const number = result.NUMBER || result.number;
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const typeLabel = type === 'customizing' ? 'Customizing' : 'Workbench';
+
+    if (success && number) {
+      console.log(`\n✅ Transport ${number} created (${typeLabel} request).\n`);
+      console.log(`   To use it now: abapgit-agent pull --transport ${number}`);
+    } else {
+      const error = result.ERROR || result.error || result.MESSAGE || result.message || 'Could not create transport request';
+      console.error(`❌ Error: ${error}`);
+      process.exit(1);
+    }
+  },
+
+  async _check(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport check');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CHECK', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const passed = result.PASSED === true || result.passed === true ||
+                   result.PASSED === 'X' || result.passed === 'X';
+    const issues = result.ISSUES || result.issues || [];
+    const desc = result.DESCRIPTION || result.description || '';
+    const owner = result.OWNER || result.owner || '';
+    const date = result.DATE || result.date || '';
+
+    console.log(`\n🔍 Checking transport ${number}...`);
+    if (desc) console.log(`\n   Description: ${desc}`);
+    if (owner) console.log(`   Owner: ${owner}`);
+    if (date) console.log(`   Date: ${date}`);
+
+    if (passed || issues.length === 0) {
+      console.log(`\n✅ Transport check passed — no issues found.`);
+      console.log(`   Ready to release: abapgit-agent transport release --number ${number}`);
+    } else {
+      console.log(`\n⚠️  Transport check completed with warnings/errors:\n`);
+
+      const typeW = 6;
+      const objW = 21;
+      const msgW = 44;
+      const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+
+      console.log(`  ${'Type'.padEnd(typeW)}  ${'Object'.padEnd(objW)}  Message`);
+      console.log(`  ${'─'.repeat(typeW)}  ${'─'.repeat(objW)}  ${'─'.repeat(msgW)}`);
+
+      for (const issue of issues) {
+        const type = issue.TYPE || issue.type || '';
+        const objType = issue.OBJ_TYPE || issue.obj_type || '';
+        const objName = issue.OBJ_NAME || issue.obj_name || '';
+        const text = issue.TEXT || issue.text || '';
+        const icon = type === 'E' ? '❌' : type === 'W' ? '⚠️ ' : 'ℹ️ ';
+        const obj = objType && objName ? `${objType} ${objName}` : objType || objName;
+        console.log(`  ${icon.padEnd(typeW)}  ${pad(obj, objW)}  ${text}`);
+      }
+
+      console.log(`\n  ${issues.length} issue(s) found. Fix before releasing.`);
+    }
+  },
+
+  async _release(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport release');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'RELEASE', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const message = result.MESSAGE || result.message || '';
+    const error = result.ERROR || result.error || '';
+    const desc = result.DESCRIPTION || result.description || '';
+
+    if (success) {
+      console.log(`\n🚀 Releasing transport ${number}...`);
+      if (desc) console.log(`\n   Description: ${desc}`);
+      console.log(`\n✅ Transport ${number} released successfully.`);
+    } else {
+      console.error(`\n❌ Could not release transport ${number}.`);
+      if (error) {
+        console.error(`\n   Error: ${error}`);
+      } else if (message) {
+        console.error(`\n   Error: ${message}`);
+      }
+    }
+  },
+
+  _prompt(question) {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+};

package/src/config.js

@@ -141,6 +141,62 @@ function getProjectInfo() {
   return projectConfig?.project || null;
 }
 
+/**
+ * Get conflict detection configuration from project-level config
+ * Precedence: CLI flag > project config > default ('abort')
+ * @returns {Object} Conflict detection config with mode and reason
+ */
+function getConflictSettings() {
+  const projectConfig = loadProjectConfig();
+
+  if (projectConfig?.conflictDetection) {
+    const validModes = ['ignore', 'abort'];
+    const mode = projectConfig.conflictDetection.mode;
+    if (mode && !validModes.includes(mode)) {
+      console.warn(`⚠️  Warning: Invalid conflictDetection.mode '${mode}' in .abapgit-agent.json. Must be one of: ${validModes.join(', ')}. Falling back to 'abort'.`);
+      return { mode: 'abort', reason: null };
+    }
+    return {
+      mode: mode || 'abort',
+      reason: projectConfig.conflictDetection.reason || null
+    };
+  }
+
+  // Default: abort (conflict detection on by default)
+  return { mode: 'abort', reason: null };
+}
+
+/**
+ * Get transport hook configuration from project-level config
+ * @returns {{ hook: string|null, description: string|null }}
+ */
+function getTransportHookConfig() {
+  const projectConfig = loadProjectConfig();
+  if (projectConfig?.transports?.hook) {
+    return {
+      hook: projectConfig.transports.hook.path || null,
+      description: projectConfig.transports.hook.description || null
+    };
+  }
+  return { hook: null, description: null };
+}
+
+/**
+ * Get transport operation settings from project-level config
+ * @returns {{ allowCreate: boolean, allowRelease: boolean, reason: string|null }}
+ */
+function getTransportSettings() {
+  const projectConfig = loadProjectConfig();
+  if (projectConfig?.transports) {
+    return {
+      allowCreate:  projectConfig.transports.allowCreate  !== false,
+      allowRelease: projectConfig.transports.allowRelease !== false,
+      reason:       projectConfig.transports.reason || null
+    };
+  }
+  return { allowCreate: true, allowRelease: true, reason: null };
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
@@ -150,5 +206,8 @@ module.exports = {
   getWorkflowConfig,
   getSafeguards,
   getProjectInfo,
-  loadProjectConfig
+  getConflictSettings,
+  loadProjectConfig,
+  getTransportHookConfig,
+  getTransportSettings
 };

package/src/utils/debug-daemon.js

@@ -67,6 +67,17 @@ async function startDaemon(config, sessionId, socketPath, snapshot) {
 
   const session = new DebugSession(adt, sessionId);
 
+  // Pin the SAP_SESSIONID so _restorePinnedSession() works inside the daemon.
+  // DebugSession.attach() normally sets pinnedSessionId, but the daemon skips
+  // attach() and reconstructs the session from the snapshot.  Without this,
+  // any CSRF refresh that AdtHttp performs internally (401/403 retry → HEAD
+  // request → new Set-Cookie) silently overwrites the session cookie and routes
+  // subsequent IPC calls to the wrong ABAP work process → HTTP 400.
+  if (snapshot && snapshot.cookies) {
+    const m = snapshot.cookies.match(/SAP_SESSIONID=([^;]*)/);
+    if (m) session.pinnedSessionId = m[1];
+  }
+
   // Remove stale socket file from a previous crash
   try { fs.unlinkSync(socketPath); } catch (e) { /* ignore ENOENT */ }
 
@@ -85,6 +96,17 @@ async function startDaemon(config, sessionId, socketPath, snapshot) {
     process.exit(code || 0);
   }
 
+  // On SIGTERM (e.g. pkill from ensure_breakpoint cleanup), attempt to release
+  // the frozen ABAP work process before exiting.  Without this, killing the
+  // daemon leaves the work process paused at the breakpoint until SAP's own
+  // session-timeout fires (up to several minutes).
+  process.once('SIGTERM', async () => {
+    try {
+      await session.terminate();
+    } catch (e) { /* ignore — best effort */ }
+    cleanupAndExit(0);
+  });
+
   const server = net.createServer((socket) => {
     resetIdle();
     let buf = '';

package/src/utils/debug-repl.js

@@ -76,6 +76,11 @@ async function startRepl(session, initialState, onBeforeExit) {
 
   renderState(position, source, variables);
 
+  // Keep the ADT stateful session alive with periodic getStack() pings.
+  // SAP's ICM drops session affinity after ~60 s of idle, causing stepContinue
+  // to route to the wrong work process (HTTP 400) when the user eventually quits.
+  session.startKeepalive();
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -178,6 +183,7 @@ async function startRepl(session, initialState, onBeforeExit) {
 
       } else if (cmd === 'q' || cmd === 'quit') {
         console.log('\n  Detaching debugger — program will continue running...');
+        session.stopKeepalive();
         try {
           await session.detach();
         } catch (e) {
@@ -190,6 +196,7 @@ async function startRepl(session, initialState, onBeforeExit) {
 
       } else if (cmd === 'kill') {
         console.log('\n  Terminating program (hard abort)...');
+        session.stopKeepalive();
         try {
           await session.terminate();
         } catch (e) {
@@ -213,7 +220,23 @@ async function startRepl(session, initialState, onBeforeExit) {
   });
 
   rl.on('close', async () => {
+    // stdin closed (EOF or Ctrl+D) without an explicit 'q' or 'kill' command.
+    // Detach so the ABAP work process is released — without this the WP stays
+    // frozen in SM50 (e.g. when attach is started with </dev/null stdin and
+    // readline gets immediate EOF before the user can type a command).
+    if (!exitCleanupDone) {
+      session.stopKeepalive();
+      try { await session.detach(); } catch (e) { /* ignore */ }
+    }
     await runExitCleanup();
+    // Drain stdout/stderr before exiting so the OS TCP stack has flushed the
+    // outbound stepContinue request bytes. process.exit() tears down file
+    // descriptors immediately — without this the WP can stay frozen if the
+    // socket buffer hasn't been written to the NIC yet.
+    await new Promise(resolve => {
+      if (process.stdout.writableEnded) return resolve();
+      process.stdout.write('', resolve);
+    });
     process.exit(0);
   });
 

package/src/utils/debug-session.js

@@ -38,7 +38,7 @@ const STATEFUL_HEADER = { 'X-sap-adt-sessiontype': 'stateful' };
  * @param {number}   maxRetries - Max additional attempts after the first (default 3)
  * @param {number}   delayMs    - Wait between retries in ms (default 1000)
  */
-async function retryOnIcmError(fn, maxRetries = 3, delayMs = 1000) {
+async function retryOnIcmError(fn, maxRetries = 12, delayMs = 2000) {
   let lastErr;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
@@ -64,6 +64,56 @@ class DebugSession {
   constructor(adtHttp, sessionId) {
     this.http = adtHttp;
     this.sessionId = sessionId;
+    this.pinnedSessionId = null;
+    this._keepaliveTimer = null;
+  }
+
+  /**
+   * Start a periodic keepalive that pings ADT every 30 seconds.
+   * SAP's ICM drops stateful session affinity after ~60 s of idle, causing
+   * subsequent debug requests to route to the wrong work process (HTTP 400).
+   * Calling getStack() regularly keeps the connection warm.
+   * Call stopKeepalive() before detach/terminate to avoid racing the close.
+   */
+  startKeepalive() {
+    if (this._keepaliveTimer) return;
+    this._keepaliveTimer = setInterval(async () => {
+      try { await this.getStack(); } catch (e) { /* best-effort */ }
+    }, 30000);
+    if (this._keepaliveTimer.unref) this._keepaliveTimer.unref();
+  }
+
+  stopKeepalive() {
+    if (this._keepaliveTimer) {
+      clearInterval(this._keepaliveTimer);
+      this._keepaliveTimer = null;
+    }
+  }
+
+  /**
+   * Restore the pinned SAP_SESSIONID into the HTTP client's cookie jar.
+   *
+   * SAP ADT debug sessions are bound to a specific frozen ABAP work process
+   * via the SAP_SESSIONID cookie.  AdtHttp updates this cookie automatically
+   * from every response's Set-Cookie header and replaces it on CSRF refresh
+   * (401/403 retry).  When the cookie rotates mid-session the next request
+   * routes to a different ABAP session that has no debug state, causing
+   * HTTP 400 "Service cannot be reached".
+   *
+   * This method reverts any rotation that occurred since attach() by replacing
+   * the current SAP_SESSIONID value with the one captured at attach time.
+   * It is a no-op when called before attach() (pinnedSessionId is null).
+   */
+  _restorePinnedSession() {
+    if (!this.pinnedSessionId || !this.http.cookies) return;
+
+    // Replace whatever SAP_SESSIONID= value is currently in the cookie jar
+    // with the pinned one.  The cookie jar is a semicolon-separated string,
+    // e.g. "SAP_SESSIONID=ABC123; sap-usercontext=xyz".
+    this.http.cookies = this.http.cookies.replace(
+      /SAP_SESSIONID=[^;]*/,
+      `SAP_SESSIONID=${this.pinnedSessionId}`
+    );
   }
 
   /**
@@ -95,6 +145,14 @@ class DebugSession {
       this.sessionId = debugSessionId;
     }
 
+    // Pin the SAP_SESSIONID cookie that was active when we attached.
+    // All subsequent stateful operations must present this exact cookie so
+    // that SAP routes them to the same frozen ABAP work process.
+    if (this.http.cookies) {
+      const match = this.http.cookies.match(/SAP_SESSIONID=([^;]*)/);
+      if (match) this.pinnedSessionId = match[1];
+    }
+
     return this.sessionId;
   }
 
@@ -126,6 +184,7 @@ class DebugSession {
     // (no suspended session left).  Treat both 200 and 500 as "continued".
     if (method === 'stepContinue') {
       return retryOnIcmError(async () => {
+        this._restorePinnedSession();
         try {
           await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
             contentType: 'application/vnd.sap.as+xml',
@@ -146,6 +205,7 @@ class DebugSession {
     }
 
     return retryOnIcmError(async () => {
+      this._restorePinnedSession();
       await this.http.post(`/sap/bc/adt/debugger?method=${method}`, '', {
         contentType: 'application/vnd.sap.as+xml',
         headers: { ...STATEFUL_HEADER, 'Accept': 'application/xml' }
@@ -173,6 +233,8 @@ class DebugSession {
    * @returns {Promise<Array<{ name: string, type: string, value: string }>>}
    */
   async getVariables(name = null) {
+    this._restorePinnedSession();
+
     const CT_CHILD = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.ChildVariables';
     const CT_VARS  = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.Variables';
 
@@ -254,6 +316,8 @@ class DebugSession {
    * @returns {Promise<Array<{ id: string, name: string, type: string, value: string }>>}
    */
   async getVariableChildren(parentId, meta = {}) {
+    this._restorePinnedSession();
+
     const CT_VARS  = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.Variables';
     const CT_CHILD = 'application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.ChildVariables';
 
@@ -372,6 +436,7 @@ class DebugSession {
    */
   async getStack() {
     return retryOnIcmError(async () => {
+      this._restorePinnedSession();
       // Try newer dedicated stack endpoint first (abap-adt-api v7+ approach)
       try {
         const { body } = await this.http.get(
@@ -383,9 +448,8 @@ class DebugSession {
         const frames = parseStack(body);
         if (frames.length > 0) return frames;
       } catch (e) {
-        // Re-throw ICM errors so the outer retryOnIcmError can catch them
-        if (e && e.statusCode === 400 && e.body && e.body.includes('Service cannot be reached')) throw e;
-        // Otherwise fall through to POST approach
+        // Fall through to POST approach for any GET failure (including 400 on systems
+        // that don't support the dedicated /debugger/stack endpoint)
       }
       // Fallback: POST approach (older ADT versions)
       const { body } = await this.http.post(
@@ -583,32 +647,38 @@ class DebugSession {
 
   /**
    * Terminate the debug session.
+   * Retries on transient ICM 400 errors so the ABAP work process is reliably
+   * released even when the system is under load (e.g. during test:all).
    */
   async terminate() {
-    await this.http.post('/sap/bc/adt/debugger?method=terminateDebuggee', '', {
-      contentType: 'application/vnd.sap.as+xml',
-      headers: STATEFUL_HEADER
+    await retryOnIcmError(async () => {
+      this._restorePinnedSession();
+      await this.http.post('/sap/bc/adt/debugger?method=terminateDebuggee', '', {
+        contentType: 'application/vnd.sap.as+xml',
+        headers: STATEFUL_HEADER
+      });
     });
   }
 
   /**
    * Detach from the debuggee without killing it.
-   * Issues a stepContinue so the ABAP program resumes running.
+   * Issues a single stepContinue so the ABAP program resumes running.
+   *
+   * ADT returns HTTP 200 when the WP resumes (regardless of whether it
+   * later hits another breakpoint — there is no way to distinguish "still
+   * running" from "re-hit breakpoint" in the stepContinue response alone).
+   * Sending a second stepContinue to an already-running WP races with the
+   * program's own execution and can stall the WP mid-run (e.g. while a
+   * Code Inspector job is in flight), so we issue exactly one request.
    *
-   * stepContinue is a long-poll in ADT — it only responds when the program
-   * hits another breakpoint (200) or finishes (500), which may be never.
-   * We use postFire() which resolves as soon as the request bytes are
-   * flushed to the TCP send buffer — no need to wait for a response.
-   * The existing session cookies are used so ADT recognises the request.
+   * Callers (e.g. the REPL 'q' handler) must delete all breakpoints before
+   * calling detach() to prevent an immediate re-hit on the same line.
    */
   async detach() {
     try {
-      await this.http.postFire('/sap/bc/adt/debugger?method=stepContinue', '', {
-        contentType: 'application/vnd.sap.as+xml',
-        headers: STATEFUL_HEADER
-      });
+      await this.step('stepContinue');
     } catch (e) {
-      // Ignore — fire-and-forget; errors here mean the session already closed.
+      // Ignore — session may have already closed.
     }
   }
 }

package/src/utils/transport-selector.js

@@ -0,0 +1,289 @@
+/**
+ * Transport selector utility
+ * Resolves a transport request number for the pull command when none is configured.
+ *
+ * Strategy:
+ *   - Non-interactive (AI mode, CI): run a project-configured Node.js hook
+ *   - Interactive (TTY): show a numbered picker (list, scope-switch, create, skip)
+ */
+
+const path = require('path');
+
+/**
+ * Returns true when running non-interactively (no TTY, CI, AI coding tool).
+ * Can be forced with NO_TTY=1 env var.
+ */
+function isNonInteractive() {
+  if (process.env.NO_TTY === '1') return true;
+  return !process.stdout.isTTY || !process.stdin.isTTY;
+}
+
+/**
+ * Load and execute a hook module.
+ * The hook must export an async function({ config, http }) → string|null.
+ *
+ * @param {string} hookPath - Absolute path to the hook module
+ * @param {object} context  - { config, http }
+ * @returns {Promise<string|null>}
+ */
+async function runHook(hookPath, context) {
+  const hookFn = require(hookPath);
+  const result = await hookFn(context);
+  return typeof result === 'string' ? result : null;
+}
+
+/**
+ * Fetch open transport requests from ABAP.
+ * Returns normalised lowercase-key objects.
+ *
+ * @param {object} http
+ * @param {string} scope - 'mine' | 'task' | 'all'
+ * @returns {Promise<Array>}
+ */
+async function fetchTransports(http, scope = 'mine') {
+  try {
+    const result = await http.get(`/sap/bc/z_abapgit_agent/transport?scope=${scope}`);
+    const raw = result.TRANSPORTS || result.transports || [];
+    return raw.map(t => ({
+      number:      t.NUMBER      || t.number      || '',
+      description: t.DESCRIPTION || t.description || '',
+      owner:       t.OWNER       || t.owner       || '',
+      date:        t.DATE        || t.date        || ''
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create a new transport request.
+ * @param {object} http
+ * @param {string} description
+ * @returns {Promise<string|null>} transport number or null
+ */
+async function createTransport(http, description) {
+  try {
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CREATE', description: description || '' },
+      {}
+    );
+    return result.NUMBER || result.number || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Interactive picker — shown in TTY mode.
+ * Presents a numbered menu; supports scope switching, create, and skip.
+ *
+ * @param {object} http
+ * @returns {Promise<string|null>}
+ */
+async function interactivePicker(http) {
+  const readline = require('readline');
+
+  let scope = 'mine';
+  let transports = [];
+  let fetchError = false;
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+  const fetchAndDisplay = async () => {
+    transports = await fetchTransports(http, scope);
+    fetchError = transports.length === 0;
+
+    const scopeLabel = { mine: 'my transports', task: 'transports where I have a task', all: 'all open transports' }[scope];
+    process.stderr.write(`\nSelect a transport request (showing: ${scopeLabel}):\n\n`);
+
+    if (transports.length > 0) {
+      transports.forEach((t, i) => {
+        process.stderr.write(`  ${i + 1}. ${t.number}  ${t.description}  (${t.owner}, ${t.date})\n`);
+      });
+      process.stderr.write('  ' + '─'.repeat(61) + '\n');
+    } else {
+      if (fetchError) {
+        process.stderr.write('  ⚠️  Could not fetch transports from ABAP system.\n');
+      } else {
+        process.stderr.write('  No open transport requests found.\n');
+      }
+      process.stderr.write('  ' + '─'.repeat(61) + '\n');
+    }
+
+    if (scope !== 'task') process.stderr.write('  s. Show transports where I have a task\n');
+    if (scope !== 'all') process.stderr.write('  a. Show all open transports\n');
+    process.stderr.write('  c. Create new transport request\n');
+    process.stderr.write('  0. Skip (no transport request)\n\n');
+  };
+
+  await fetchAndDisplay();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const answer = (await ask('Enter number or option: ')).trim().toLowerCase();
+
+    if (answer === '0') {
+      rl.close();
+      return null;
+    }
+
+    if (answer === 's') {
+      scope = 'task';
+      await fetchAndDisplay();
+      continue;
+    }
+
+    if (answer === 'a') {
+      scope = 'all';
+      await fetchAndDisplay();
+      continue;
+    }
+
+    if (answer === 'c') {
+      const desc = (await ask('Description: ')).trim();
+      rl.close();
+      const number = await createTransport(http, desc);
+      if (number) {
+        process.stderr.write(`\n✅ Created transport ${number}\n`);
+        return number;
+      } else {
+        process.stderr.write('\n❌ Could not create transport request.\n');
+        return null;
+      }
+    }
+
+    const idx = parseInt(answer, 10);
+    if (!isNaN(idx) && idx >= 1 && idx <= transports.length) {
+      rl.close();
+      return transports[idx - 1].number;
+    }
+
+    process.stderr.write(`Invalid selection '${answer}'. Enter a number, s, a, c, or 0.\n`);
+  }
+}
+
+/**
+ * Build the `run` helper that is passed to hooks in AI mode.
+ *
+ * run(command) — accepts a full CLI command string, e.g.:
+ *   run('transport list --scope task')
+ *   run('transport create --description "My transport"')
+ *
+ * Splits on whitespace, forces --json, captures output, returns parsed JSON.
+ *
+ * @param {object}   config               - Loaded ABAP config
+ * @param {object}   http                 - Pre-built AbapHttp instance
+ * @param {Function} loadConfig           - Config factory (from pull context)
+ * @param {Function} AbapHttp             - AbapHttp constructor (from pull context)
+ * @param {Function} getTransportSettings - Transport settings getter (from pull context)
+ * @returns {Function|undefined}          - The run helper, or undefined if factories are missing
+ */
+function buildRun(config, http, loadConfig, AbapHttp, getTransportSettings) {
+  if (!loadConfig || !AbapHttp) return undefined;
+
+  return async function run(command) {
+    const [commandName, ...args] = command.trim().split(/\s+/);
+    const cmdModule = require(`../commands/${commandName}`);
+
+    // Always force --json so output is parseable
+    const runArgs = args.includes('--json') ? args : [...args, '--json'];
+
+    // Reuse the already-authenticated http instance
+    const MockAbapHttp = function MockAbapHttp() { return http; };
+
+    const runContext = {
+      loadConfig: () => config,
+      AbapHttp: MockAbapHttp,
+      getTransportSettings: getTransportSettings || (() => ({ allowCreate: true, allowRelease: true, reason: null }))
+    };
+
+    // Capture console.log output; override process.exit to throw instead of exit
+    const captured = [];
+    const origLog = console.log;
+    const origExit = process.exit;
+    console.log = (...a) => captured.push(a.map(String).join(' '));
+    process.exit = (code) => { throw new Error(`process.exit(${code})`); };
+
+    try {
+      await cmdModule.execute(runArgs, runContext);
+    } finally {
+      console.log = origLog;
+      process.exit = origExit;
+    }
+
+    const output = captured.join('');
+    if (!output) throw new Error(`run("${command}") produced no output`);
+    return JSON.parse(output);
+  };
+}
+
+/**
+ * Main export — selects a transport request for use in the pull command.
+ * Returns the transport number, or null to proceed without one.
+ *
+ * @param {object}   config               - Loaded ABAP config
+ * @param {object}   http                 - Pre-built AbapHttp instance
+ * @param {Function} [loadConfig]         - Config factory (enables run helper in hook context)
+ * @param {Function} [AbapHttp]           - AbapHttp constructor (enables run helper in hook context)
+ * @param {Function} [getTransportSettings] - Transport settings getter
+ * @returns {Promise<string|null>}
+ */
+async function selectTransport(config, http, loadConfig, AbapHttp, getTransportSettings) {
+  // Hook takes precedence over the interactive picker — runs in both TTY and non-TTY mode
+  const hookConfig = module.exports._getTransportHookConfig();
+  if (hookConfig && hookConfig.hook) {
+    const hookPath = path.resolve(process.cwd(), hookConfig.hook);
+    const run = buildRun(config, http, loadConfig, AbapHttp, getTransportSettings);
+    try {
+      return await module.exports.runHook(hookPath, { config, http, run });
+    } catch {
+      return null;
+    }
+  }
+
+  // No hook configured — fall back based on context
+  if (isNonInteractive()) {
+    return null;  // AI/CI mode: proceed without transport
+  }
+
+  // Manual mode: interactive picker
+  return interactivePicker(http);
+}
+
+/**
+ * Read transport hook config from .abapgit-agent.json
+ * (mirrors getConflictSettings pattern in config.js)
+ */
+function _getTransportHookConfig() {
+  const fs = require('fs');
+  const projectConfigPath = path.join(process.cwd(), '.abapgit-agent.json');
+
+  if (!fs.existsSync(projectConfigPath)) return null;
+
+  try {
+    const projectConfig = JSON.parse(fs.readFileSync(projectConfigPath, 'utf8'));
+    if (projectConfig && projectConfig.transports?.hook) {
+      return {
+        hook: projectConfig.transports.hook.path || null,
+        description: projectConfig.transports.hook.description || null
+      };
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  return null;
+}
+
+module.exports = {
+  isNonInteractive,
+  runHook,
+  fetchTransports,
+  createTransport,
+  interactivePicker,
+  selectTransport,
+  buildRun,
+  _getTransportHookConfig
+};