Add Scriptless and TM pages, unpublished old pages

docs/modules/automation-testing/pages/scripting/auto-generate-an-appium-script.adoc

@@ -5,7 +5,7 @@ Learn how to generate an Appium script from a manual session, so you can start b
 
 == Before you start
 
-* xref:scriptless-automation:create-a-baseline-session.adoc[]
+* xref:_scriptless-automation:create-a-baseline-session.adoc[]
 
 [#_export_your_script]
 == Export your script
@@ -14,7 +14,7 @@ After creating the baseline session, search for your session, open the session o
 
 image:automation-testing:export-appium-script-context.png[width=1200, alt="The automated test case for the selected session."]
 
-Next, select the *Export Appium Script* icon. If you don't see an icon, check if your session xref:test-management:remediation/index.adoc[requires remediation].
+Next, select the *Export Appium Script* icon. If you don't see an icon, check if your session xref:_test-management:remediation/index.adoc[requires remediation].
 
 image:automation-testing:export-appium-script-closeup.png[width=750, alt="Session overview tabs, including Automated Test Case, Jira Integration, Rerun, and the Appium Export icon."]
 

docs/modules/organization/pages/device-bundles/create-a-device-bundle.adoc

@@ -1,7 +1,7 @@
 = Create a device bundle
 :navtitle: Create a device bundle
 
-Learn how to create a new device bundle so users in your organization can run xref:scriptless-automation:index.adoc[Scriptless Automation] on devices in parallel.
+Learn how to create a new device bundle so users in your organization can run xref:_scriptless-automation:index.adoc[Scriptless Automation] on devices in parallel.
 
 [NOTE]
 Device bundles are operating system (OS) specific so Android and iOS devices cannot be bundled together.

docs/modules/organization/pages/device-bundles/manage-device-bundles.adoc

@@ -1,7 +1,7 @@
 = Manage device bundles
 :navtitle: Manage device bundles
 
-Learn how to manage the device bundles in your organization so users can use them to run xref:scriptless-automation:index.adoc[Scriptless Automation] on devices in parallel. You can only manage device bundles xref:device-bundles/create-a-device-bundle.adoc[you or your team created].
+Learn how to manage the device bundles in your organization so users can use them to run xref:_scriptless-automation:index.adoc[Scriptless Automation] on devices in parallel. You can only manage device bundles xref:device-bundles/create-a-device-bundle.adoc[you or your team created].
 
 == View a device bundle
 

docs/modules/reporting/pages/usage-report/report-metadata.adoc

@@ -44,23 +44,23 @@ xref:manual-testing:start-a-mixed-session.adoc[Mixed test sessions].
 
 === Scriptless on Manual
 
-xref:scriptless-automation:index.adoc[Scriptless test sessions] that use a manual test session as the base.
+xref:_scriptless-automation:index.adoc[Scriptless test sessions] that use a manual test session as the base.
 
 === Scriptless on Automation
 
-xref:scriptless-automation:index.adoc[Scriptless test sessions] that use an automation test session as the base.
+xref:_scriptless-automation:index.adoc[Scriptless test sessions] that use an automation test session as the base.
 
 === Test Case
 
-xref:test-management:index.adoc[Test cases].
+xref:_test-management:index.adoc[Test cases].
 
 === Text Validation
 
-xref:test-management:validation/text-validation.adoc[Text validation] within a Scriptless session.
+xref:_test-management:validation/text-validation.adoc[Text validation] within a Scriptless session.
 
 === Color Validation
 
-xref:test-management:validation/color-text-validation.adoc[Color text validation] within a Scriptless session.
+xref:_test-management:validation/color-text-validation.adoc[Color text validation] within a Scriptless session.
 
 === Font Size (WBI)
 

docs/modules/scriptless-automation/nav.adoc

@@ -1,13 +1,6 @@
 .xref:index.adoc[]
 
-* xref:scriptless-automation:create-a-baseline-session.adoc[]
-
-* Get a session ID
-** xref:get-a-session-id/using-the-kobiton-portal.adoc[]
-** xref:get-a-session-id/using-the-kobiton-api.adoc[]
-
-* xref:run-scriptless-with-the-kobiton-portal.adoc[]
-* xref:run-scriptless-with-the-kobiton-api.adoc[]
-* xref:automation-testing:scripting/auto-generate-an-appium-script.adoc[]
-* xref:scriptless-best-practices.adoc[]
-* xref:scriptless-requirements.adoc[]
+* xref:scriptless-automation:baseline-session.adoc[]
+* xref:scriptless-automation:run-scriptless.adoc[]
+* xref:scriptless-automation:run-scriptless-api.adoc[]
+* xref:scriptless-automation:best-practices.adoc[]

docs/modules/scriptless-automation/pages/baseline-session.adoc

@@ -0,0 +1,80 @@
+= Create a baseline session
+
+== Overview
+
+A baseline session is a manual test session that serves as the source for automated test execution. It captures how an application is exercised on a real device and provides the reference used to create a test case.
+
+Baseline sessions are created through manual interaction in the Kobiton platform and are required before a test can be run automatically.
+
+== What is a baseline session?
+
+A baseline session is a manual session performed on a real device through the platform.
+
+During the session, a user interacts with the application as they would during normal testing. These interactions are captured by the platform and later reused to define a test flow.
+
+Once converted into a test case, the baseline session becomes the reference for future test execution. Test cases can also be used to generate Appium scripts.
+
+== Create a baseline session
+
+Baseline sessions are created by running a manual test session with capture enabled and completing a defined test flow.
+
+=== 1. Start a manual session and enable capture
+
+From the Devices view in the Kobiton platform, select a device and launch a manual session.
+
+Before interacting with the application, select the *Play* button to enable session capturing mode.
+
+image::capture-session-icon.png[width=600,alt="Capture Session icon in Session Explorer"]
+
+Session capturing mode improves the accuracy of element detection by capturing precise element bounding boxes. Actions performed while capturing is enabled provide the most reliable results for scriptless execution.
+
+If your test requires an application, install or select the app at the start of the session.
+
+NOTE: Actions performed before capture is enabled are still saved with the session, but may result in reduced element accuracy during automated execution.
+
+=== 2. Perform the test flow
+
+Interact with the application as you would during normal testing.
+
+While capture is enabled, the platform captures supported interactions and associates them with the current application state. These captured interactions form the basis of the baseline session.
+
+Focus on completing a single, intentional test flow from start to finish.
+
+=== 3. End the session and convert it to a test case
+
+When the test flow is complete, exit the manual session by selecting the *X* icon.
+
+The session then opens in Session Explorer, where it can be converted into a test case. Once converted, the test case is managed through Test Management, where it can be reviewed, edited, and used to create test runs.
+
+To convert a session into a test case or learn more about Test Management, see xref:test-management:test-cases.adoc[Test cases].
+
+image::convert-test-case.png[width=600,alt="Convert Test Case in Session Explorer"]
+
+== What makes a good baseline
+
+Baseline sessions are most reliable when they reflect a clear and stable test flow.
+
+Good baseline sessions typically:
+
+* Follow a single, intentional path through the application
+* Use supported interactions only
+* Avoid unnecessary navigation or exploratory actions
+
+Baseline quality directly affects how reliably a test can be executed later.
+
+== Platform considerations
+
+Baseline sessions are platform-specific.
+
+Separate baseline sessions are required for Android and iOS, even when the application behavior is similar.
+
+Baseline sessions must target a supported application context: a web application (Safari or Chrome), an app installed from the App Repository, or an existing app already available on the device.
+
+Manual sessions can be converted into test cases even if unsupported actions were captured. Test cases that contain unsupported actions cannot be executed in a test run until those steps are removed and the test case is saved as a new version.
+
+== Related pages
+
+* xref:test-management:test-cases.adoc#_convert_to_test_case[Convert a session to a Test Case]
+* xref:scriptless-automation:run-scriptless.adoc[Run a Scriptless test]
+* xref:test-management:index.adoc[Test management]
+* xref:scriptless-automation:best-practices.adoc[Best practices]

docs/modules/scriptless-automation/pages/best-practices.adoc

@@ -0,0 +1,103 @@
+= Best practices for Scriptless automation
+
+== Overview
+
+Best practices help improve the reliability and consistency of Scriptless automation.
+
+These guidelines are not required to run Scriptless tests, but following them can reduce execution issues and minimize the need for remediation as test coverage expands.
+
+== Baseline session best practices
+
+Baseline sessions are most effective when they reflect a clear and stable test flow.
+
+When creating a baseline session:
+
+* Enable session capture by selecting the *Play* button before interacting with the application to ensure accurate element detection.
+* Use a physical keyboard instead of the virtual device keyboard.
+* Follow a single, intentional path through the application.
+* Be precise and deliberate when interacting with the application. For example, tap the center of a button instead of the edge.
+* Dismiss pop-ups by selecting the close control instead of tapping outside the pop-up.
+* Avoid rapid swiping or tapping. Wait at least 2 seconds between actions.
+* Avoid tapping auto-corrected text.
+* Use supported interactions only.
+
+Baseline sessions that are focused and repeatable are easier to reuse and more reliable during execution.
+
+== Unsupported actions
+
+Scriptless automation does not support the following actions:
+
+* Double tap
+* Double Home
+* Pinch or zoom
+* Screenshot
+* Set time zone
+* Image injection
+* Custom gestures
+
+== Test design considerations
+
+Keeping tests concise improves maintainability.
+
+Shorter test flows are easier to understand, execute, and troubleshoot. Instead of extending a single test to cover many variations, related tests can be grouped and executed together.
+
+If a test requires frequent adjustments to continue running, recreating the baseline session may be more effective than repeatedly refining an unstable definition.
+
+== Execution consistency
+
+Consistency across devices and environments improves execution reliability.
+
+When possible:
+
+* Use similar device types, operating system versions, and screen layouts.
+* Follow Kobiton device setup instructions before running Scriptless tests.
+* Keep test devices in light mode.
+
+Greater variation across devices may increase the likelihood of execution differences that require review.
+
+Greater variation across devices may increase the likelihood of execution differences that require review.
+
+== Scaling test execution
+
+Tests can be executed across many devices once a baseline has proven reliable.
+
+Expanding execution incrementally allows issues to surface early and keeps results easier to interpret. Grouping related tests helps maintain clarity as execution scales.
+
+== Reducing remediation effort
+
+Remediation is an expected part of automated execution, but its frequency can often be reduced.
+
+Before starting a new test run, review the test case and update any steps that no longer match the current application flow.
+
+Clear baseline sessions, consistent navigation paths, and stable application states all contribute to smoother execution. Repeated remediation across many steps may indicate that the underlying test flow no longer reflects current application behavior.
+
+== Workflows to avoid
+
+Some workflows are not suited for Scriptless automation.
+
+Avoid using Scriptless automation for apps or flows with:
+
+* First-run states that differ from later app launches
+* Dynamic content that changes frequently or unpredictably
+* Random pop-ups, such as promotional messages
+* Non-English app text
+* Complex gesture-based interactions
+* Gaming apps
+
+These workflows may require script-based automation for greater control.
+
+== Unsupported frameworks and environments
+
+Scriptless automation does not support:
+
+* Espresso
+* UIAutomator
+* XCUITest
+* GameDriver
+* Virtual devices
+
+== Related pages
+
+* xref:scriptless-automation:baseline-session.adoc[Create a baseline session]
+* xref:scriptless-automation:run-scriptless.adoc[Run a Scriptless test]
+* xref:test-management:remediations.adoc[Remediations]

docs/modules/scriptless-automation/pages/index.adoc

@@ -1,10 +1,63 @@
-= Scriptless Automation
-:navtitle: Scriptless Automation
+= Scriptless automation
 
-Automate your tests without writing scripts.
+== Overview
 
-image:automation-testing:automation-testing-index-context.png[width=1000,alt="A context to Scriptless Automation"]
+Scriptless automation enables automated test execution based on interactions captured during manual sessions. Tests are generated from real device usage and can be executed repeatedly without requiring users to write or maintain automation scripts.
 
-== In this section
+Within the Kobiton platform, this capability builds on manual testing by capturing user interactions in a structured form and reusing them for repeatable execution across devices.
 
-include::../nav.adoc[lines=2..]
+Scriptless automation is used to reduce the effort required to run repetitive tests while preserving visibility into how tests are executed on real devices.
+
+== How it works
+
+Scriptless automation is based on capturing test behavior once and reusing it for execution.
+
+=== Manual sessions as the source
+
+Testing begins with a manual session performed on a real device through the Kobiton platform. During the session, user interactions with the application are captured.
+
+=== Tests created from captured interactions
+
+Captured interactions are converted into test definitions that represent a complete test flow. These definitions are stored and managed independently of execution.
+
+=== Tests executed without user-written scripts
+
+When a test is run, the platform executes the captured interactions automatically. Automation scripts are generated and managed by the platform; users do not need to author or maintain code to run tests.
+
+== Requirements
+
+Scriptless automation requires the following:
+
+* An active Kobiton account with access to Test Management
+* A supported mobile platform (Android or iOS)
+* A supported application context, as described below
+
+=== Application under test
+
+The application under test must be accessible in a form supported for Scriptless automation.
+
+Depending on the application type:
+
+* *Native or hybrid mobile apps* must be uploaded to the Kobiton App Repository before creating or running tests. Direct app upload during test execution is not supported.
+* *Web applications* can be tested through supported mobile browsers without uploading an app.
+* *Preinstalled system applications* already available on the device (such as Clock or Calculator) can be tested without additional setup.
+
+== Limitations
+
+Scriptless automation tests are platform-specific. Separate tests are required for Android and iOS.
+
+Some application types and flows are not supported or are a poor fit for Scriptless automation, including:
+
+* Game engine–based applications, such as Unity-based apps
+* Canvas-based applications, where UI elements are not represented as standard view hierarchies
+* Highly dynamic interfaces that change structure frequently at runtime
+* Authentication flows that rely on one-time credentials, such as OTP or multi-factor authentication
+
+In these scenarios, script-based automation or alternative testing approaches may be more appropriate.
+
+== Related pages
+
+* xref:scriptless-automation:baseline-session.adoc[Create a baseline session]
+* xref:scriptless-automation:run-scriptless.adoc[Run a Scriptless test]
+* xref:scriptless-automation:best-practices.adoc[Best practices]
+* xref:test-management:index.adoc[Test management]