sap-ai-dev-toolkit 0.9.9918 → 0.9.9920

package/.github/skills/sap-integration-architect/SKILL.md

@@ -9,7 +9,7 @@ Use this skill to design an integration on SAP Integration Suite before anything
 
 Tool names shown in PascalCase (such as `GetSource` or `LintABAP`) are logical names; the live MCP surface exposes them as lowercase snake_case. A server scoped to a single destination (the normal case for generated `mcp.json` entries) exposes them unprefixed, so `GetSource` appears as `get_source` and `LintABAP` as `lint_abap`; when several destinations share one server, each name is destination-prefixed with its slug for disambiguation (for example `cfd_run_query`). Always call the exact names returned by `tools/list`.
 
-The Integration Suite companion server is never destination-prefixed. Read its live `tools/list` once and follow each returned input schema; `cpi_*` tools appear only when CPI credentials are configured and `apim_*` tools only when APIM credentials are configured.
+The Integration Suite companion server is never destination-prefixed. Discover its live `tools/list` and follow each returned schema. Operational tools require their own component credentials; `integration_connection_info({verify:true})` supplies the full capability catalog, native handoffs and primary sources even for unconfigured components. Use current [tool contracts](../../../tools.md), not remembered endpoints or aliases.
 
 ## 1. Requirement checklist
 
@@ -17,12 +17,14 @@ Consumers and providers · direction and trigger (synchronous request/reply, asy
 
 ## 2. Assess before designing (read-only)
 
-- `integration_connection_info` — which tenants are bound.
-- CPI: `cpi_list_packages`, `cpi_list_iflows`, `cpi_get_iflow` (models and configuration of similar flows), `cpi_list_service_endpoints`, `cpi_get_iflow_runtime_status`, `cpi_list_message_logs` with status `FAILED`, `cpi_get_message_log`.
-- APIM: `apim_list_api_providers`, `apim_get_api_provider`, `apim_list_api_proxies`, `apim_get_api_proxy`, `apim_list_virtual_hosts`.
-- SAP backend: confirm on the ABAP destination server that the OData service is published (`PublishServiceBinding` belongs to RAP service delivery) and take the service path from it; check SAP-delivered APIs with `GetAPIReleaseState`.
-
-Reuse matching providers, packages and iFlows instead of duplicating them.
+- Call `integration_connection_info({verify:true})`; record environment label, immutable bound hosts, configured components, access results and public-contract evidence. A label never switches tenants or credentials. Different environments require independently configured servers; common-subaccount identity remains unverified without authoritative evidence.
+- CPI: reuse `cpi_list_packages`, `cpi_list_package_artifacts`, `cpi_list_iflows`, `cpi_get_iflow` and `cpi_get_artifact`; inspect configuration, versions, runtime and endpoints.
+- APIM: reuse providers/proxies/products, inspect virtual hosts, `apim_get_api_proxy_status`, registered API documentation and `apim_inspect_api_proxy_security`.
+- Traverse every relevant `{items,next_cursor}` collection with unchanged filters until verified end, or report `complete:false` and its `stop_reason`. A first page, `total:null` or missing continuation is not exhaustive inventory. Reuse matching providers, packages, iFlows and shared content instead of duplicating them.
+- Inspect exact targets with `integration_inspect_dependencies`; retain `bundle_sha256`, configuration-aware `state_sha256`, literal alias/provider/KVM/certificate references and unresolved dynamic dependencies. Never expose source, configuration values or secrets in summaries.
+- SAP backend: confirm on the ABAP destination server that the OData service is published (`PublishServiceBinding` belongs to RAP service delivery) and use its reported service path; check SAP-delivered APIs with `GetAPIReleaseState`.
+- Distinguish absent configuration, unauthenticated, forbidden, unavailable, untested, error, empty data and unknown entitlement. HTTP 401/403/404 does not establish the missing role, activation or entitlement cause. No probe may provision services or grant roles. Core CF provisioning requires explicit setup-wizard approval; optional setup stores existing separately typed credentials only.
+- Generic OData discovery is not authority to read arbitrary entities/functions or pass through raw schemas. Use only implemented safe metadata projections; monitoring never reads payloads, message bodies, secrets or source bundles. Keep artifact/source inspection explicitly in the authoring phase.
 
 ## 3. Pattern decision guide
 
@@ -40,18 +42,40 @@ Cloud Integration: prefer the vetted `https-request-reply-http` template (HTTPS
 
 | Hop | How it authenticates |
 |---|---|
-| Client → API Management | Toolkit-created proxies carry no policies; the client `Authorization` header is forwarded unchanged. Add API-key or OAuth policies in the APIM UI when the gateway must authenticate consumers. |
+| Client → API Management | Include API-key or OAuth verification in `apim_create_api_proxy.policies` to protect the first deployed revision. Without policies, the client `Authorization` header is forwarded unchanged. |
 | Client or APIM → Cloud Integration | OAuth token from a Process Integration Runtime `integration-flow` client with role `ESBMessaging.send`; calls without it get HTTP 401. |
 | Cloud Integration → backend | Receiver authentication None, Basic, OAuth2 Client Credentials, Client Certificate or Principal Propagation; security materials are referenced by name and must already exist on the tenant. |
-| API Management → backend | API providers store no credentials; use Cloud Connector principal propagation or forward the client credentials. |
+| API Management → backend | API providers store no credentials; use Cloud Connector principal propagation, forward the client credentials, or include `basic_auth_from_kvm` with securely populated encrypted backend credentials. |
+
+Never request or print secrets. Configure credentials through the MCP host environment or hidden setup input. Consumer keys are provisioned by `devhub_create_application` and used privately by `apim_test_api`; OAuth verification works without DEVHUB. No credentials in plans or results.
+
+## 5. Plan release, operations and recovery
+
+Design the entire lifecycle, then delegate implementation to `integration-suite-delivery`:
+
+1. Discover capabilities and exact host/object identities → reuse content → inspect dependencies and digests → approve author/configure actions. Preserve source defaults separately from fresh configured values; partial configuration restoration must stop the release.
+2. Save an explicit retained iFlow version with `cpi_save_iflow_version` using fresh current-version/bundle preconditions. A patch update changes the draft, not retained history. Validate that **selected saved version** with `cpi_validate_iflow`; HTTP acceptance is not `Passed`.
+3. Preview and separately approve `integration_snapshot_content` for immutable private original ZIPs/configuration. Check `integration_check_release_readiness` against exact target versions (`cpi_iflow:<id>` / `apim_proxy:<id>` keys). Readiness needs the latest matching successful validation, including configured-state digest, within its 15-minute lifetime; failed, unknown, stale or configuration-changed evidence cannot reuse an older success.
+4. Separately approve selected-version deployment or native promotion. Continue an accepted deployment with `cpi_get_deployment_task` after timeout; never repeat the deploy POST. Require build/task success **and fresh runtime identity for the requested version**, not an old `STARTED`. Same-version redeploy without freshness proof remains unverified. Endpoint registration/log visibility may lag.
+5. APIM create/import, routing, policy and documentation changes deploy a new revision and may replace the draft. Plan private intended-content/preserved-resource read-back separately from runtime observation and approved consumer smoke reads. Existing `DEPLOYED`, an import acceptance or a runtime URL alone proves neither the new content nor effective security. `apim_test_api` supports APIM-only issuer-pinned OAuth from a privately read named CF key; API-key mode additionally needs DEVHUB.
+6. Plan bounded UTC `[from,to)` observations, at most 31 days: CPI `cpi_get_message_statistics`, MPL/run/step evidence and `cpi_get_operational_summary`; APIM aggregate/series/error-group reports with source watermark. No traffic is not healthy; incomplete sources stay explicit. Rates need complete nonzero denominators; no fabricated percentiles, consumer analytics or instantaneous-health claims.
+7. Use `integration_monitoring_readiness` and native ALM/ANS evidence. An administrator owns dedicated monitoring credentials, collection/categories, Health Monitoring and thresholds/notifications. Require observed collection and separately approved synthetic notification delivery before claiming continuous monitoring verified; API access or valid rules alone is insufficient.
+8. Plan incident ownership and separately approved recovery/retirement. Retained CPI rollback is exact-version deployment. Snapshot restore previews current state hashes, checks every target and restores CPI active draft/configuration only; deployment is separate. APIM ZIP restoration imports/deploys a new revision, not native retained Revert. Neither rollback nor restore reverses messages, datastores, security material, issued tokens or receiver transactions.
+
+### Operational design recipes
 
-Never ask for, print or store secrets. Credentials belong in the MCP host environment (`CPI_SERVICE_KEY`, `APIM_SERVICE_KEY`, or `VCAP_SERVICES`).
+- **Failed business correlation:** freeze exact message/business identifiers and UTC window; use exact MPL filters and `cpi_trace_message`, enumerate runs and freeze the selected run ID (or explicitly record the latest chosen run), then page all selected-run steps. No correlation means seed-only evidence, not a guessed trace or APIM linkage; never read bodies/attachments.
+- **Stuck asynchronous work:** combine broker limits, warning/critical/inactive queues, named queue metadata, overdue stores/entries and variable metadata. Global stores use `integration_flow:''`. Store totals differ from fetched entry counts; positive backlog/depth or processing alone is not unhealthy. Resolve a MessageId before linking MPL. Queue retry/consume/start/stop is not automatic remediation.
+- **APIM policy versus target errors:** compare `apim_get_analytics`, `apim_get_analytics_series` and `apim_get_api_error_breakdown` over the same window/proxy scope. Pair policy/target error totals and weighted latency with static policy attachments, provider, KVM and issuer evidence. Static configuration is not proof of effective authentication/trust, and source lag prevents current-health inference.
+- **Certificate impact:** map `cpi_get_certificate_health` findings to referenced aliases/dependencies. Referenced expired/not-yet-valid certificates block; unrelated expiry is an inventory finding, not an unrelated release blocker. Missing/invalid validity and unproven trust/connectivity remain unknown.
+- **Consumer offboarding:** inventory exact owner, subscriptions and legacy product links with Developer Hub tools. Separately approve unsubscription and fresh dry-run application deletion; incomplete/ambiguous relationships block, changed dependencies invalidate approval, and partial failure stops. API-key invalidation, native key/secret rotation, portal-access revoke and issued OAuth-token revocation are different outcomes; none may be substituted for another.
 
-## 5. Errors, operations and platform timing
+### Native promotion and wider Suite boundaries
 
-- A receiver error fails the message and returns HTTP 500 to the caller; define how the consumer reacts.
-- Operate with message processing logs: status, error text and custom header properties (payloads are never read).
-- Proven on live tenants: deployments can stay `STARTING` beyond a minute (`cpi_deploy_iflow` returns `timed_out` after 50 seconds; then poll `cpi_get_iflow_runtime_status`); service endpoints and message logs appear minutes after `STARTED`; API proxy read-back lags after import. Build these waits into acceptance tests instead of treating them as failures.
+- `integration_transport_readiness` must cover every selected package artifact group/version, not the first page or first 20 iFlows. `ctms_list_nodes` proves node visibility only. Authorized owners verify Content Agent assembly, export node, destinations and route, name the request set, separately approve assembly/upload/import, track native request/action logs, then verify content/version/runtime through an **independently target-bound server**. Snapshots/iFlow ZIPs are not MTARs; partial import and reset-to-Repeatable are not rollback.
+- Use ANS rule inspection/validation and narrowly approved condition/subscription changes only. cTMS alerts use trusted internal ANS integration with intentional event/node scope, not obsolete `ALERT_NOTIFICATION_SERVICE` destinations. APIM anomaly events differ from analytics polling; CPI failures are not automatically ANS events.
+- Narrow adapters: standalone `event_mesh_get_queue`; AEM `aem_list_brokers`, `aem_get_broker`, `aem_get_broker_operation`; broker-local SEMP `aem_list_queues`; Open Connectors identity reads and separately approved enabled-state action; Edge local metadata/MPL reads. Keep each credential/host authority separate. Queue metadata is not consumption, connector disable is not deletion or provider-health proof, and Edge metadata does not establish component-control schemas.
+- Follow source-backed native sequences in the capability catalog/[tool contracts](../../../tools.md) for Suite-embedded Event Mesh, TPM agreement activation/interchanges, Advisor MIG/MAG validation/export, Assessment API Reference, Migration extraction/evaluation/conversion, new Integration Cell API/MCP design/deploy/monitor, Edge Operations Cockpit, shared-artifact creation/version history, queue controls/retry, CPI cancellation/design deletion, APIM retained Revert/standalone Undeploy and consumer key rotation/portal revoke. Include exact identities, prerequisites, authorized owner, safety impact and post-action reads. Never replace a missing/inaccessible public contract with a guessed API, generated Partner Directory edits or broader platform administration.
 
 ## 6. Naming and versioning rules
 
@@ -60,17 +84,17 @@ Never ask for, print or store secrets. Credentials belong in the MCP host enviro
 - API proxy and provider names: letters, digits, `_`, `-`. Reserved provider names: `TC_*`, `DEST_CI`, `APIMGMT_PORTAL`, `ON_PREM`, `Apimgmt_rt*`, and ContentCatalog.
 - Base paths and sender paths: unique, lowercase, versioned (for example `/s4/salesorder/v1`); no `//`, `..` or trailing `/`.
 - API proxy descriptions are stored as HTML (`<`, `>`, `&` come back escaped).
-- Every iFlow update needs `expected_version` from a fresh read and bumps the patch version; every proxy update is a new revision.
+- Every iFlow update needs `expected_version` from a fresh read and bumps the draft patch version; only explicit SaveAsVersion creates retained history. APIM import/update/policy/documentation changes deploy a new revision; disclose that release effect.
 
-## 7. Design deliverable
+## 7. Design deliverable and approval
 
-1. Chosen pattern, rationale and rejected alternatives.
-2. Component flow (consumer → gateway → integration → backend).
-3. Per-hop table: host, port, path, route (Internet or Cloud Connector), authentication.
-4. Objects to create or change: package, iFlows (template or custom), externalized parameters, security materials, value mappings, API providers (`sap-client` where needed), API proxies, gateway policies, key value maps, API products.
-5. Ordered build calls with their exact confirmation strings: `cpi_create_package` (`CREATE CPI PACKAGE <id>`), `cpi_create_iflow` (`CREATE IFLOW <id>`), `cpi_update_iflow_configuration` (`CONFIGURE IFLOW <id>`), `cpi_update_iflow` (`UPDATE IFLOW <id>`), `cpi_set_user_credential` (`SET USER CREDENTIAL <name>`), `cpi_set_oauth2_client_credential` (`SET OAUTH2 CLIENT CREDENTIAL <name>`), `cpi_deploy_iflow` (`DEPLOY IFLOW <id>`), `cpi_deploy_artifact` (`DEPLOY ARTIFACT <id>`), `cpi_undeploy_artifact` (`UNDEPLOY ARTIFACT <id>`), `apim_create_api_provider` (`CREATE API PROVIDER <name>`), `apim_create_api_proxy` (`CREATE API PROXY <name>`), `apim_update_api_proxy` (`UPDATE API PROXY <name>`), `apim_create_key_value_map` (`CREATE KEY VALUE MAP <name>`), `apim_attach_api_proxy_policies` (`UPDATE API PROXY POLICIES <name>`), `apim_create_api_product` (`CREATE API PRODUCT <name>`).
-6. Prerequisites outside the tools, with owners: Cloud Connector mappings, `integration-flow` clients, applications and API keys, API proxy undeploy, role assignments.
-7. Acceptance tests and how they are verified: `cpi_get_iflow_runtime_status` is `STARTED`, `cpi_list_service_endpoints` returns the endpoint, `apim_get_api_proxy` returns `runtime_url` and state, and test calls appear as `COMPLETED` message logs.
-8. Risks and open questions.
+1. Chosen pattern, rationale and rejected alternatives; component flow (consumer → gateway → integration → backend).
+2. Per-hop host, port, path, route (Internet or Cloud Connector), authentication and separately managed credential owner.
+3. Complete objects/identities/versions to reuse, create, configure or retire: package, iFlows/template, parameters, security aliases, shared artifacts, providers (`sap-client` where needed), proxies, policies, KVMs, products and consumer subscriptions.
+4. Ordered build/release calls with exact live-schema confirmation strings, fresh optimistic hashes/versions, selected-version validation, immutable snapshot and readiness gates. Include partial-progress stop conditions; no implicit deployment or mutation retries.
+5. Deployment versus native-promotion approvals, target-bound verification and explicit runtime/synthetic-test approval. Consumer onboarding/governance, Cloud Connector, runtime clients, account entitlements, platform roles and native operations have named owners.
+6. Bounded observation window, expected signals, completeness/watermark limits, native collection/delivery evidence, diagnostic recipes and incident/recovery ownership.
+7. Separately approved recovery/retirement sequence. `devhub_unsubscribe_application` and `devhub_delete_application` handle guarded consumer retirement, not APIM cleanup. APIM product/proxy deletion remains dependency-blocked; explicit-list cleanup never cascades into consumers/providers/KVMs/credentials. Include full target set, `allow_deployed` / `allow_active_subscriptions` permissions where applicable and returned dry-run confirmations.
+8. Observed evidence, unresolved prerequisites and source-backed next actions, clearly separating acceptance, read-back, runtime proof and unexercised native criteria.
 
-Present the deliverable and wait for explicit user approval before any create, update, configure, deploy or undeploy call. There are no delete tools; design-time deletion and API proxy undeploy are manual steps in the Integration Suite UI.
+Present tenant hosts, exact actions and confirmations and obtain explicit user approval before **every write**, including validation, saved history, snapshots, deployment, alert changes, restore and deletion. A correct confirmation or preview hash is not approval. Never ask for secrets in chat or broaden authority to grant roles, provision optional services, consume/retry messages or bypass governance.

package/README.md

@@ -225,29 +225,84 @@ Use either:
 
 The configured identity must be a separate least-privileged read-only HANA user. The server rejects bindings that offer only HDI deployment credentials and never falls back to `hdi_user`/`hdi_password`. Its tools are limited to connection identity, object listing/descriptions, and parameterized row reads capped at 200 rows; credential-like columns are blocked, and there is no arbitrary SQL, DDL/DML, grant, deployment, or undeploy tool. Use the existing project deployment workflow yourself after reviewing the exact generated artifact diff and target. The SAP HANA Node.js driver is provided under the SAP Developer License Agreement.
 
-### Integration Suite (Cloud Integration + API Management)
+### Integration Suite lifecycle and optional services
 
-Every interactive `sap-ai-dev --setup` asks **"Add the SAP Integration Suite tools?"** right before it writes the MCP configuration. The step shows which of CPI and APIM have credentials (never the secrets themselves). Enter means **yes** when credentials were found and **no** otherwise; type `y` or `n` to override. An existing `integration-suite` entry is kept without asking. With `--tools`, the choice is part of the companion checkbox instead, and when nothing is detected the setup menu also offers **Set up only the SAP Integration Suite tools**.
+The separate `integration-suite` stdio MCP server covers bounded discovery, authoring, saved-version validation, private backups, release evidence, deployment-task continuation, runtime verification, diagnosis and guarded retirement. The existing **SAP Integration Architect / Developer** agents and their skills use the same lifecycle; there is no separate operator agent. [Tool contracts and native handoffs](tools.md#separate-optional-integration-suite-server) · [inventory](inventory.md#separate-optional-integration-suite-server).
 
-To set up only this server, run **`sap-ai-dev --setup-integration`**. In both routes the credential step:
+#### Setup and authority
 
-1. **Checks detected credentials online.** It signs in and runs one read-only request per tool area (packages, deployed artifacts, message logs, security material, number ranges, Partner Directory, data stores, JMS; API proxies, providers, products, key value maps, virtual hosts, and policy readiness, which exports an existing API proxy bundle the way `apim_attach_api_proxy_policies` does). Each area is marked ✓, ✗ (missing role) or – (not available on the tenant or plan, or no proxy exists yet to test the export with).
-2. **Uses the logged-in Cloud Foundry space (default when `cf` is logged in).** It finds the Process Integration Runtime instance with plan `api` (`it-rt`) and the API Management instance with plan `apiportal-apiaccess`, lets you choose when there are several, and reuses or creates one service key named `sap-ai-dev-integration` on it. The key is then verified and saved like a pasted one. Roles are fixed on the instance, so when the key signs in but lacks roles, or a side has no instance, the wizard offers to create a dedicated instance (`sap-ai-dev-integration-cpi` with `AuthGroup_Administrator`, `AuthGroup_BusinessExpert`, `AuthGroup_IntegrationDeveloper`, `AuthGroup_TenantPartnerDirectoryConfigurator`, `AccessAllAccessPoliciesArtifacts`; `sap-ai-dev-integration-apim` with `APIPortal.Administrator`). It never does this without your `y`.
-3. **Lets you paste a service key.** Paste a CPI key (Process Integration Runtime, plan `api`) or an APIM key (API Management, plan `apiportal-apiaccess`), either as JSON (multi-line paste works; input is hidden) or as the path to the downloaded `.json` file. The key is verified the same way before it is saved.
-4. **Saves only what the server needs.** The URL, token URL, client id and secret go to `~/.config/sap-ai-dev-toolkit/integration-suite.json`, readable only by you. The secret is never printed and never written to `mcp.json`. A key that cannot sign in is saved only if you confirm.
+Interactive `sap-ai-dev --setup` asks **"Add the SAP Integration Suite tools?"** before writing MCP configuration, preserves existing entries, and shows configured identities without credential values. Enter defaults to yes when credentials exist, no otherwise. `--tools` includes the companion checkbox; the empty-landscape menu offers Integration Suite-only setup. Run **`sap-ai-dev --setup-integration`** to configure only this server.
 
-Environment credentials take precedence over a saved key. Re-check at any time with `sap-ai-integration --check`, or ask the agent to call `integration_connection_info` with `verify: true`. Configure CPI, APIM, or both; per side the first match wins:
+- Detected credentials receive read-only capability checks. Core Cloud Foundry setup discovers `it-rt/api`, `apimanagement-apiportal/apiportal-apiaccess` and `apimanagement-devportal/devportal-apiaccess`; it can reuse/create the `sap-ai-dev-integration` key and, with explicit approval, dedicated `sap-ai-dev-integration-cpi`, `sap-ai-dev-integration-apim` or `sap-ai-dev-integration-devhub` instances. It pins plans/brokers visible to the targeted space, rejects ambiguous or other-organization plans, and does not grant entitlements.
+- Core service keys and separately typed optional records can be pasted as hidden JSON or supplied by downloaded file path. The user-only `~/.config/sap-ai-dev-toolkit/integration-suite.json` stores only normalized credentials (directory 0700/file 0600), never `mcp.json`; saving a key that cannot sign in requires confirmation.
+- Optional discovery/setup accepts **existing credentials only**. It does not provision services, create optional service keys, activate capabilities, assign roles or retarget Cloud Foundry. Startup and capability probes never provision anything.
 
-- Explicit `CPI_URL`, `CPI_TOKEN_URL`, `CPI_CLIENT_ID`, `CPI_CLIENT_SECRET` (or the `APIM_*` equivalents).
-- `CPI_SERVICE_KEY` / `APIM_SERVICE_KEY` containing the service-key JSON: a Process Integration Runtime `api` plan key (ClientId/Secret) for CPI, an API Management `apiportal-apiaccess` key for APIM. Certificate-based keys are rejected.
-- One `VCAP_SERVICES` binding of service `it-rt` / `apimanagement-apiportal`; override the label with `CPI_VCAP_SERVICE` / `APIM_VCAP_SERVICE` and select an instance with `CPI_BINDING` / `APIM_BINDING`.
-- The key saved by `sap-ai-dev --setup-integration` (lowest precedence).
+Core precedence remains per-side: complete explicit `CPI_URL/CPI_TOKEN_URL/CPI_CLIENT_ID/CPI_CLIENT_SECRET` (or `APIM_*` / `DEVHUB_*`) → matching `*_SERVICE_KEY` JSON → one unambiguous `VCAP_SERVICES` binding → saved setup key. `*_VCAP_SERVICE` and `*_BINDING` select custom labels/instances. Certificate-based core keys are rejected. Optional environment JSON overrides only its matching stored record; malformed optional input disables that adapter, not usable core clients.
 
-CPI needs the roles `WorkspacePackagesRead`, `WorkspacePackagesEdit`, `WorkspacePackagesConfigure`, `WorkspaceArtifactsDeploy`, and `MonitoringDataRead` for packages, iFlows, deployment and message logs; security material, number ranges, Partner Directory, data stores, and JMS tools additionally need the matching `api`-plan roles for those areas (for example `DataStoresAndQueuesRead` and `AuthGroup_TenantPartnerDirectoryConfigurator`), and a missing role surfaces as an HTTP 403 in the tool error. APIM needs `APIPortal.Administrator`. Writes are limited to create, update, configure, deploy, and undeploy, each gated by an exact confirmation string such as `CREATE IFLOW <iflow_id>` or `UPDATE API PROXY POLICIES <name>`; there are no delete tools. Passwords, client secrets, and key value map values are write-only: tools accept them and never return them. Anything without a dedicated tool can be read through `cpi_odata_get` / `apim_odata_get`. Run `sap-ai-integration --help` for the full variable list.
+| Optional input | Authentication boundary |
+|---|---|
+| `CTMS_SERVICE_KEY` | Existing raw `uri`/`uaa` key or normalized OAuth record; token suffix normalization is cTMS-specific. |
+| `ANS_CONFIG` | `{url,username,password}` technical-client Basic; rule write permission is separate from inspection. |
+| `EVENT_MESH_CONFIG` | `{url,tokenUrl,clientId,clientSecret,probeQueueName?}` management OAuth; preserve the exact token endpoint. No named probe means untested, with no token/API request. |
+| `AEM_CONFIG` | `{apiToken}` for the fixed US GA cloud API at `https://api.solace.cloud`; not a SEMP credential. |
+| `AEM_SEMP_CONFIG` | `{url,msgVpnName,username,password}` broker-local Basic, configured VPN only, private scoped session reuse. |
+| `OPEN_CONNECTORS_CONFIG` | `{url,userSecret,organizationSecret}`; URL includes `/elements/api-v2`. Fresh private Element authorization is restricted to the named enabled-state action. |
+| `EDGE_CONFIG` | `{url,clientId,clientSecret}` local Basic at the API virtual-host origin; preserve `/local`. |
 
-`npm run test:live:integration` runs the end-to-end scenarios against a real tenant. It **creates and deploys** packages, iFlows, API providers, proxies, products, key value maps, user credentials, number ranges, and Partner Directory parameters suffixed with `RUN` (required, unique per run), so use a non-production subaccount. Scenarios that call iFlows over HTTP also need `CPI_RUNTIME_SERVICE_KEY`, a Process Integration Runtime `integration-flow` key with role `ESBMessaging.send`; the companion server itself never uses that key.
+`integration_connection_info({verify:true})` reports the full capability catalog, actual registered actions, primary contract sources and concrete native handoffs. `verification.ok` means configured **core access**, not optional completeness, entitlement or continuous monitoring. HTTP 401/403/404/501 distinguish authentication/access/endpoint evidence; they do not identify a missing role or establish non-entitlement. CPI role requirements include `WorkspacePackagesRead`, `WorkspacePackagesEdit`, `WorkspacePackagesConfigure`, `WorkspaceArtifactsDeploy`, `MonitoringDataRead` and area-specific security/store/JMS/Partner Directory permissions. APIM uses `APIPortal.Administrator`; Developer Hub API access uses `AuthGroup.API.Admin`.
 
-The live runner uses the same credential precedence as the server, including saved setup keys, explicit OAuth variables, and VCAP bindings; service-key environment variables are not required. The full suite needs both CPI and APIM. `ONLY` selects scenarios without enabling the others: for a CPI-only, read-only error-handling check, run `RUN=CHECK26 ONLY=S72 npm run test:live:integration`. This checks malformed and missing message-log lookups; it does not verify deployment or message execution. For read-only checks across every configured capability area, run `node src/integration-server.mjs --check` from a checkout with dependencies installed.
+Reports carry immutable `INTEGRATION_ENVIRONMENT` labels (default `default`). Labels never select authority: bound hosts/object identities do. Use independently configured server instances for source and target environments, and restart after credential changes. Secrets, consumer keys, tokens, KVM values and payloads are not returned by metadata/diagnostic tools. Explicit source readers remain a separate authoring boundary; generic OData readers permit only implemented safe projectors. Metadata discovery is not permission for arbitrary roots or function imports.
+
+#### Release, observation and recovery
+
+1. **Discover and reuse.** Inspect actual live `tools/list`, hosts and capabilities. Follow collection `items` / `next_cursor` with the same target/filters; `total:null`, inaccessible sources and bounded/incomplete traversal are not exhaustive inventories or no-traffic evidence.
+2. **Inspect exact dependencies.** `integration_inspect_dependencies` privately resolves literal credential/certificate/provider/KVM references and returns unresolved dynamic/shared/custom references, names and digests. `bundle_sha256` binds sorted member paths/bytes; `state_sha256` also binds fresh CPI configured values/types. A configuration-only change invalidates prior state evidence.
+3. **Approve authoring/configuration.** Present the exact tenants, objects, effects and tool confirmation strings. Prefer the vetted HTTPS → Request Reply → HTTP iFlow template; use fresh `expected_version` for updates. Draft patch bumps are not retained versions. APIM imports and policy/documentation changes also deploy.
+4. **Save, validate, back up and check readiness.** Use `cpi_save_iflow_version`, validate that **selected saved version** with `cpi_validate_iflow`, capture original ZIP/configuration with `integration_snapshot_content`, then inspect `integration_check_release_readiness` against exact expected versions. Latest matching failed/unknown/stale validation cannot be replaced by an older success. Required missing aliases, version mismatch and referenced invalid certificates block; unrelated expired certificates do not. Dynamic/unreadable evidence needs review.
+5. **Approve deployment or native promotion separately.** CPI returns HTTP acceptance, build/task and runtime evidence separately. Old `STARTED` is not proof of the requested deployment; same-version redeploy needs fresh identity. Continue `cpi_get_deployment_task` after timeout without another POST. APIM imports compare all intended/preserved resources privately; content read-back and an old deployed state do not prove the new runtime revision.
+6. **Verify on the bound target.** Check exact runtime version/deployment identity, endpoints and separately approved consumer GETs; correlate the actual test message/window. `apim_get_api_proxy_status` is management evidence, not a health check. Promotion requires an independent target-bound server, not a relabelled source process.
+7. **Observe and diagnose.** MPL listing/counts and APIM aggregates/series/error groups use fixed UTC `[from,to)` windows of at most 31 days. Server counts are distinct from samples; no traffic, partial access and unknown status stay distinct. APIM means are weighted; lag is explicit and no p95/p99 is fabricated. Positive queue depth/processing alone is not unhealthy. Global datastore scope uses `integration_flow:""`; inspect overdue totals, run/step evidence and referenced certificate impact without reading bodies or automatically retrying messages.
+8. **Approve recovery and retirement independently.** Snapshot restore verifies private files, tenant identities and every fresh configuration-aware target digest before writes, then rechecks each target; partial progress stops without automatic compensation. CPI restores active draft/configuration only, never implicitly deploys. APIM snapshot import creates a new imported revision, not native retained Revert. Restore cannot reverse receiver transactions, processed messages or issued tokens.
+
+`integration_transport_readiness` traverses all four package artifact groups and batches iFlow checks beyond the 20-target boundary, checks exact versions/matching backups and inspects a named cTMS node. Incomplete backup traversal blocks; a matching sample cannot establish coverage. Results are only `blocked` or `needs_admin_confirmation`. Content Agent assembly, export nodes/destinations/routes, named request sets, separate upload/import approvals and native action logs remain administrator-owned. A snapshot/ZIP is not an MTAR; partial import/reset to Repeatable is not rollback.
+
+`integration_monitoring_readiness` and ANS rule tools inspect scoped native references and configuration, not continuous delivery. Cloud ALM requires a dedicated CPI API credential, Landscape Management, Integration & Exception Monitoring categories/collection, Health Monitoring and native thresholds/notifications. Require observed collection and approved synthetic delivery. cTMS uses trusted internal ANS integration, not the obsolete `ALERT_NOTIFICATION_SERVICE` destination scheduled for removal Q4 2026. The server installs no scheduler, telemetry daemon or alert backend.
+
+Standalone Event Mesh, GA AEM, separate broker SEMP, Open Connectors and Edge have narrow metadata adapters. Suite-embedded Event Mesh, TPM agreement/interchange operations, Integration Advisor MIG/MAG export, Assessment/Migration workflows and new Integration Cell API/MCP administration use the [documented native handoffs](tools.md#native-lifecycle-handoffs), never invented endpoints or generic-reader bypasses.
+
+#### API exposure and consumer lifecycle
+
+Secure the first APIM revision by supplying approved `policies` to `apim_create_api_proxy` (up to 10 templates). For API-key plus technical backend Basic, include `verify_api_key` and `basic_auth_from_kvm`, with credentials privately populated in an encrypted KVM. Providers store no backend credentials. `apim_edit_policy_steps` supports digest-guarded ordering/conditions/removal for one named phase; preserve unrelated attachments/resources and review all references before removal.
+
+`apim_get_api_proxy` resolves a sanitized `runtime_url` from publication or virtual host/base path, including missing leading separators and non-default ports. Public provider/proxy metadata URLs omit credentials, query strings and fragments; malformed named metadata fails closed. Product reads expose allowlisted metadata, not credential-bearing expansions. Provider/proxy creation preflights are name-only; a completed write followed by failed read-back must be inspected, not blindly repeated.
+
+`apim_get_api_documentation` / `apim_update_api_documentation` inspect/update registered OpenAPI 2.0/3.0/3.1 JSON (maximum 1 MiB), pinned to the deployed HTTPS runtime URL. Updates preserve other resources, deploy and verify decoded content with only established portal normalization. Follow `next_operation_offset` (100 operations/page), or select one path/method. Publishing a product does not create operation definitions or grant backend/OAuth authority.
+
+1. Find the intended owner using `devhub_list_developers`; separately approve developer onboarding/approval when required.
+2. Approve `devhub_create_application` for exact application/developer/published product identities. SAP provisions consumer credentials privately; responses show metadata/key availability only. Inspect/add subscriptions without bypassing external governance.
+3. Use `apim_test_api` with **one** authentication source: `application_id` requires Developer Hub, while `oauth:{service_instance,service_key,scope}` works with APIM alone. OAuth privately reads the named CF key and pins its token endpoint to the deployed VerifyJWT issuer before acquisition. Probe `/$metadata` or documented entity GET with `$top` 1–10; no arbitrary URL, redirects, business row values or secret output.
+4. For offboarding, inspect `devhub_list_subscriptions`, approve exact `devhub_unsubscribe_application` changes, then preview `devhub_delete_application` owner/dependency evidence and its fresh single-use approval. Legacy/incomplete/ambiguous links block; active subscriptions need explicit permission. Named absence does not prove issued OAuth-token revocation.
+
+APIM product/proxy deletion is separate: dependencies block, deployed proxy removal requires `allow_deployed:true`, and `apim_cleanup_api_objects` accepts explicit lists only (100 each/200 total), dry-run first. A preview hash binds objects/permissions, not user approval. Recheck dependencies, remove selected products before proxies and stop on failed/unverified deletion; never cascade into applications, providers, KVMs or credentials.
+
+Native key rotation/private consumer cutover, portal-user revoke, external governance callbacks, CPI design deletion/cancellation and standalone APIM undeploy remain distinct authorized workflows. Product unpublish and portal revoke do not revoke issued tokens. [Developer Hub API-access prerequisite](https://help.sap.com/docs/integration-suite/sap-integration-suite/api-access-plan-for-developer-hub).
+
+#### Safe connected verification
+
+`npm test` exercises every supported Integration Suite tool through the production MCP server and SDK against isolated local services. Regression cases cover mismatched identities, forged/runtime-bound cursors, paging and UTF-8/archive limits, denied/malformed responses, stale state, partial writes, accepted-but-unverified actions and private authentication boundaries. These checks do not certify real-tenant mutations, optional service access or backend availability.
+
+From a checkout with dependencies installed:
+
+```sh
+node scripts/check-live-integration.mjs --window-minutes 60 --top 3 --json
+```
+
+This separate checker permits configured-management GETs and exact OAuth token POSTs only. It exercises bounded CPI/MPL/counts/runs/steps/runtime/JMS/overdue-store/certificate/operational reads, APIM aggregates/series/errors and configured optional metadata adapters. It never validates, saves, configures, imports, deploys, consumes/retries messages or runs an API consumer probe. Exit 0 means requested core reads/schema checks executed—not a healthy landscape; inspect partial/degraded/unknown evidence. Missing optional credentials remain `live_unverified`. `sap-ai-integration --check` is the smaller read-only capability check.
+
+`npm run test:live:integration` is **mutating**, unlike that checker. It creates/configures/deploys tenant objects suffixed with required unique `RUN`; use only a separately approved non-production fixture set. Runtime iFlow scenarios additionally require `CPI_RUNTIME_SERVICE_KEY` (`integration-flow` plan, `ESBMessaging.send`), never used by the companion itself. The runner shares normal credential precedence; `ONLY` selects scenarios without enabling others. No live mutation is implied by local regression or read-only verification success.
+
+Lifecycle release changes: signed bounded collections and precise access evidence; continuable release validation/deployment and private configuration-bound recovery; server-side API analytics; native monitoring/promotion readiness; guarded policy/consumer changes; separately credentialed optional metadata adapters and complete native handoffs.
+Live AnalyticsService compatibility uses distinct derived aliases and an explicit source-record count. A zero-record aggregate with null sums is `no_data`, not a failed request or healthy traffic; null metrics with nonzero records remain partial.
 
 ## 💡 Example requests
 
@@ -905,6 +960,8 @@ Run the built-in Node.js test suite:
 npm test
 ```
 
+Install the checkout globally with `npm run install:local`, or use `npm run install:local -- --link` for a live workspace link. Verify without reinstalling using `npm run install:local -- --verify`: it checks the installed package version and, for a link, the actual workspace target, and refuses an outdated snapshot or a different checkout. After installation, exercise the installed executable with `sap-ai-integration --check`; npm-linked commands resolve their real entrypoint before starting the server.
+
 The package repository is [grknylmz/sap-ai-dev-toolkit](https://github.com/grknylmz/sap-ai-dev-toolkit).
 
 ## 🚀 Publishing to npm

package/dist/checksums.txt

@@ -1,5 +1,5 @@
-cefc61f6b12b273c74c1e9d0e488006508b1e30a0660ad4f8dda77dfb1da1a92  vsp-linux-x64
-17e6f4d4ea4dca78ed384b3a76189bf9a0711a862eb08d47c2019046464acb55  vsp-linux-arm64
-5a1c4cbd837eb27d9df66b04b2737ad7323128876bd7bdc41417d1ddd29d53b9  vsp-darwin-x64
-1acb86850d55a013951ad3a40d83e58f19a05333f68e2af2e8e5aa882f17f7d7  vsp-darwin-arm64
-bd41b6b2b8a99313a804fc8546f3f13ccd872425c74293dd34eb538c49ee54ed  vsp-win32-x64.exe
+885ba61e5aa31e1bfe21953040a5cdb5e06c3eb648495f03b7cb035b2fd9d2c2  vsp-linux-x64
+34f392bfbd853dd2b24abd95fda351d25633b538728371f881ee475a65904b31  vsp-linux-arm64
+cee27c146031fd932bf974ca359c6c0263c1ea1c20fe120f5244948af5ae1743  vsp-darwin-x64
+320deb50652f0a29c8624c56e7cb150cb27a4e381b42c9b8c1edda1c3ad64a81  vsp-darwin-arm64
+574885013902ccd93645ca7890cdff1c02ea769799df019f1d086d41f9e2cb71  vsp-win32-x64.exe

package/inventory.md

@@ -194,62 +194,102 @@ The process exposes no DDL, DML, arbitrary SQL, procedure-call, deployment, unde
 
 ## Separate optional Integration Suite server
 
-The Integration Suite companion is a standalone MCP process launched as `sap-ai-integration`; it is not a child of the SAP runtime and is not destination-prefixed. CPI and APIM OAuth clients come from `CPI_*`/`APIM_*` variables, `CPI_SERVICE_KEY`/`APIM_SERVICE_KEY`, one unambiguous `VCAP_SERVICES` binding per side, or (lowest precedence) a key pasted, verified online and saved user-only by `sap-ai-dev --setup-integration` in `~/.config/sap-ai-dev-toolkit/integration-suite.json`. Requests are pinned to the configured tenant origins. `cpi_*` tools are registered only when CPI is configured, `apim_*` tools only when APIM is configured. `sap-ai-integration --check` runs the same online verification from a terminal.
+The standalone `sap-ai-integration` companion is not a BAS-proxy child and never destination-prefixed. The implementation enumerates 114 distinct possible tool names; actual `tools/list` is authoritative because each core/optional authority is registered only when configured. Source and target environments require independent, immutable server bindings. `INTEGRATION_ENVIRONMENT` labels reports, never selects credentials or hosts.
+
+Core CPI/APIM/DEVHUB OAuth precedence remains explicit variables → service key → unambiguous VCAP binding → private setup store. Optional cTMS, ANS, Event Mesh, AEM cloud, broker SEMP, Open Connectors and Edge accept independently typed existing credentials only. Configuration, access, activation, entitlement and common-subaccount identity are separate evidence. No startup/read probe provisions services or keys.
+
+Collections return `{items, returned, total, complete, next_cursor, stop_reason}`; grouped artifact/partner kinds have individual pages. Resume with unchanged server/target/filters within 15 minutes. Unknown counts remain null; incomplete sources are not exhaustive, healthy or empty. Generic readers expose implemented safe metadata projectors, not arbitrary discovered entities/functions. Explicit source readers are an authoring boundary, not diagnostic passthrough.
+
+### Cross-component lifecycle
 
 | Tool | Behavior |
-| --- | --- |
-| `integration_connection_info` | Report configured sides, credential source, binding, and tenant/token hosts. `verify: true` signs in and runs one read-only request per tool area, classifying each as ok, forbidden (missing role) or unavailable. Never returns client ids or secrets. |
-| `cpi_list_packages` | List packages (max 200). |
-| `cpi_list_iflows` | List iFlows of a package. |
-| `cpi_get_iflow` | Artifact metadata, configurations, and bundle files (text capped 48 KiB each, or one file up to 90 KiB). |
-| `cpi_get_iflow_runtime_status` | Runtime status; error text when `ERROR`. |
-| `cpi_list_service_endpoints` | Deployed endpoint URLs, optionally for one iFlow. |
-| `cpi_list_message_logs` | Message processing logs filtered by iFlow, status, time window, `correlation_id`, `application_message_id`, or `custom_header` (max 100). |
-| `cpi_get_message_log` | One log with error text and custom header properties; attachments are not read. |
-| `cpi_get_message_log_steps` | Steps of the latest run (sorted by start, max 200) with step errors. |
-| `cpi_list_package_artifacts` | iFlows, value mappings, script collections, and message mappings of one package. |
-| `cpi_get_artifact` | Value mapping, script collection, or message mapping metadata plus bundle files (same caps as `cpi_get_iflow`). |
-| `cpi_get_value_mappings` | Agency pairs with values and defaults (max 500 values per pair). |
-| `cpi_list_runtime_artifacts` | Deployed artifacts, optionally by status. |
-| `cpi_get_jms_broker_status` | JMS broker capacity and non-OK queues. |
-| `cpi_list_data_stores` / `cpi_list_data_store_entries` / `cpi_list_variables` | Data store, entry, and variable metadata; payloads are not read. |
-| `cpi_list_security_material` | User credentials, OAuth2 client credentials, or keystore entries; secret fields redacted. |
-| `cpi_list_number_ranges` | Number ranges. |
-| `cpi_list_partner_parameters` | Partner Directory string parameters and binary parameter metadata. |
-| `cpi_odata_get` | Read-only GET for other `/api/v1` entity sets or `/$metadata`; `$value`, `$batch`, and `$links` rejected; secrets and artifact content redacted. |
-| `cpi_create_package` | Create a package. Confirmation `CREATE CPI PACKAGE <package_id>`. |
-| `cpi_create_iflow` | Create an iFlow from the `https-request-reply-http` template or custom BPMN. Confirmation `CREATE IFLOW <iflow_id>`. |
-| `cpi_update_iflow` | Replace/add files and parameters with an `expected_version` check and patch bump; never deletes files. Confirmation `UPDATE IFLOW <iflow_id>`. |
-| `cpi_update_iflow_configuration` | Set externalized parameters sequentially. Confirmation `CONFIGURE IFLOW <iflow_id>`. |
-| `cpi_deploy_iflow` | Deploy and wait up to 50 s (below common MCP client timeouts) for build/runtime status; `timed_out` means poll `cpi_get_iflow_runtime_status`. Confirmation `DEPLOY IFLOW <iflow_id>`. |
-| `cpi_deploy_artifact` | Deploy a value mapping, script collection, or message mapping and wait up to 50 s for runtime status. Confirmation `DEPLOY ARTIFACT <artifact_id>`. |
-| `cpi_undeploy_artifact` | Undeploy a runtime artifact and wait up to 50 s until it is gone. Confirmation `UNDEPLOY ARTIFACT <artifact_id>`. |
-| `cpi_update_package` | Merge name, short text, description, or version into a package. Confirmation `UPDATE CPI PACKAGE <package_id>`. |
-| `cpi_copy_package` | Copy a Discover package (`CREATE_COPY` with suffix or `OVERWRITE_MERGE`). Confirmation `COPY CPI PACKAGE <package_id>`. |
-| `cpi_upsert_value_mappings` | Upsert value pairs sequentially, stopping at the first failure; deploy afterwards. Confirmation `UPDATE VALUE MAPPING <artifact_id>`. |
-| `cpi_update_script_collection` | Add/replace scripts in the collection bundle. Confirmation `UPDATE SCRIPT COLLECTION <artifact_id>`. |
-| `cpi_set_user_credential` | Create or update a user credential; password write-only. Confirmation `SET USER CREDENTIAL <name>`. |
-| `cpi_set_oauth2_client_credential` | Create or update an OAuth2 client credential; secret write-only. Confirmation `SET OAUTH2 CLIENT CREDENTIAL <name>`. |
-| `cpi_upload_certificate` | Add (or with `update` replace) a PEM certificate in the system keystore. Confirmation `UPLOAD CERTIFICATE <alias>`. |
-| `cpi_set_number_range` | Create or update a number range. Confirmation `SET NUMBER RANGE <name>`. |
-| `cpi_set_partner_parameter` | Create or update a Partner Directory string or binary parameter. Confirmation `SET PARTNER PARAMETER <pid>/<id>`. |
-| `apim_list_api_providers` | List providers without credential fields. |
-| `apim_get_api_provider` | One provider with credential properties removed. |
-| `apim_list_api_proxies` | List proxies. |
-| `apim_get_api_proxy` | One proxy with endpoints, virtual hosts, deployment info, and computed `runtime_url`. |
-| `apim_list_virtual_hosts` | List virtual hosts. |
-| `apim_export_api_proxy` | Export the proxy bundle and return its files (or one file). |
-| `apim_list_api_products` / `apim_get_api_product` | Products; one product with its proxy names. |
-| `apim_list_key_value_maps` / `apim_get_key_value_map` | Key value maps; encrypted values redacted. |
-| `apim_odata_get` | Read-only GET for other Management.svc entity sets (applications, developers, certificate store references) or `/$metadata`; same guards as `cpi_odata_get`. |
-| `apim_create_api_provider` | Create an Internet or On-Premise provider; no credentials sent; reserved names rejected. Confirmation `CREATE API PROVIDER <name>`. |
-| `apim_update_api_provider` | Merge connection changes into a credential-free provider (credentialed providers are refused). Confirmation `UPDATE API PROVIDER <name>`. |
-| `apim_create_api_proxy` | Import (and deploy) a policy-free proxy for a provider or https URL target. Confirmation `CREATE API PROXY <name>`. |
-| `apim_update_api_proxy` | Export, patch base path/target/title/description in place, and re-import; policies, steps, and scripts are preserved. Confirmation `UPDATE API PROXY <name>`. |
-| `apim_attach_api_proxy_policies` | Add or replace up to 10 policies from templates or custom XML and their flow steps, then re-import. Confirmation `UPDATE API PROXY POLICIES <name>`. |
-| `apim_create_api_product` | Create (and by default publish) a product over existing proxies with optional quota. Confirmation `CREATE API PRODUCT <name>`. |
-| `apim_update_api_product` | Merge title, description, scope, quota, or publish state. Confirmation `UPDATE API PRODUCT <name>`. |
-| `apim_create_key_value_map` | Create a map (encrypted by default); values write-only. Confirmation `CREATE KEY VALUE MAP <name>`. |
-| `apim_set_key_value_map_entries` | Update existing entries and add new ones, stopping at the first failure; values write-only. Confirmation `UPDATE KEY VALUE MAP <name>`. |
-
-Confirmations are checked before any network call. The process exposes no delete tools. Secrets are write-only and never returned; message payloads, attachments, and data-store payloads are never read.
+|---|---|
+| `integration_connection_info` | Full core/optional/native catalog, immutable hosts/label, actual actions, primary contract sources and native handoffs. `verify:true` separates configured core access from optional evidence; 403 does not establish a missing role. |
+| `integration_inspect_dependencies` | Explicit bounded targets, private fresh bundle/configuration inspection, literal dependency existence, unresolved references and bundle/configuration-aware state hashes. |
+| `integration_check_release_readiness` | Exact target/version/dependency/access evidence and latest matching iFlow validation. Missing aliases, version mismatch, referenced invalid certificates or failed validation block; unreadable/dynamic/stale evidence requires review. |
+| `integration_snapshot_content` | Dry-run-first target/host preview; exact approval saves immutable original ZIPs and CPI configuration privately. No caller-selected filesystem path or private content returned. |
+| `integration_list_snapshots` | Signed bounded safe snapshot identities/hosts/hashes and explicit integrity findings. |
+| `integration_restore_snapshot` | Verify all private files, tenant bindings and fresh expected target state hashes before writes; recheck each target. CPI active draft/configuration only; APIM imports/deploys a new revision. Stop partial, no automatic compensation or transaction/token rollback. |
+| `integration_monitoring_readiness` | Actual management/native-rule evidence plus Cloud ALM/ANS setup requirements. Continuous collection and approved synthetic notification delivery remain administrator-unverified until observed. |
+| `integration_transport_readiness` | All four package groups, bounded continuations/count evidence, exact versions and iFlow checks in batches of at most 20, matching verified backups and named cTMS node. Incomplete/unchecked sources block; native assembly/upload/import/target verification remain separately approved. |
+
+### Cloud Integration
+
+| Tool | Behavior |
+|---|---|
+| `cpi_list_packages` / `cpi_list_iflows` | Bounded package/iFlow metadata inventories. |
+| `cpi_list_package_artifacts` | Four independently bounded artifact groups; a cursor requires one concrete type. Unverified navigation is explicitly incomplete. |
+| `cpi_get_iflow` / `cpi_get_artifact` | Explicit authoring reads of metadata/configuration/bundle files; text files capped at 48 KiB, selected file 90 KiB. Not a payload-reading diagnostic API. |
+| `cpi_get_value_mappings` | Explicit authoring values/defaults in nested collection envelopes; at most 20 agency pairs and 500 entries per nested collection, additionally byte-bounded. Unknown counts/traversal remain explicit, never exhaustive samples. |
+| `cpi_create_package` / `cpi_update_package` / `cpi_copy_package` | Approved creation/metadata merge or Discover copy/overwrite-merge, with object-specific confirmations. Copy HTTP acceptance is distinct from a returned copied identity; an unverified reply is not replayed. |
+| `cpi_create_iflow` | Approved vetted HTTPS → Request Reply → HTTP template or custom BPMN creation. |
+| `cpi_update_iflow` | Fresh expected-version draft patch, defaults < configured values < explicit overrides, surviving configuration reapplied. Partial progress explicit; a patch bump does not create a retained version. |
+| `cpi_update_iflow_configuration` | Ordered approved parameter writes with safe changed-name/first-failure evidence, no value output. |
+| `cpi_upsert_value_mappings` / `cpi_update_script_collection` | Approved updates to existing shared artifacts; deployment remains separate. Native source creation/retained history handoffs are documented. |
+| `cpi_save_iflow_version` | Explicit retained SaveAsVersion with current-version/bundle guard, target absence and exact read-back; validate the selected saved version next. |
+| `cpi_validate_iflow` | Approved bodyless selected-version validation. HTTP acceptance is not Passed; failed/unknown/latest state-bound evidence supersedes old success. |
+| `cpi_deploy_iflow` / `cpi_deploy_artifact` | Approved active/named deployment with separate acceptance/build/task/runtime fields. Old STARTED or unchanged same-version identity cannot prove success. |
+| `cpi_get_deployment_task` | Continue original accepted task observation, retaining the runtime baseline; never sends another deploy POST. |
+| `cpi_undeploy_artifact` | Exact approved runtime removal with bounded named-absence verification; not design-time deletion. |
+| `cpi_list_runtime_artifacts` / `cpi_get_iflow_runtime_status` / `cpi_list_service_endpoints` | Bounded runtime state/version/error/endpoint evidence, not proof that a new deployment or business request succeeded. |
+| `cpi_list_message_logs` | Fixed UTC `[from,to)` LogStart window, maximum 31 days; exact iFlow/status/correlation/application/custom-header filtering, frozen default window and best-effort cursor evidence. |
+| `cpi_get_message_statistics` | Exact server total/eight status counts, unclassified remainder, partial/inconsistent sources; zero traffic is not a health certification. |
+| `cpi_get_message_log` | Named safe MPL metadata, bounded redacted error information and credential-filtered headers; no payloads/attachments. |
+| `cpi_list_message_log_runs` / `cpi_get_message_log_steps` | Bounded member-run metadata and latest/explicit run selection frozen across paged steps, including beyond step 200. Missing message differs from no runs. |
+| `cpi_trace_message` | Exact propagated nonempty correlation only; no inferred business/APIM cross-product trace or body. |
+| `cpi_list_jms_queues` / `cpi_get_jms_queue` | Queue metadata only; numeric/boolean flags preserve unknowns. Positive depth alone is not unhealthy; no consumption/control/retry. |
+| `cpi_get_jms_broker_status` | Independent capacity/limit, warning/critical and inactive-queue observations with partial source evidence. |
+| `cpi_list_data_stores` / `cpi_list_data_store_entries` / `cpi_list_variables` | Query-free bounded metadata; global scope `integration_flow:""` allowed. Backlog/overdue totals differ from fetched rows; no payloads/variable values or invented MPL links. |
+| `cpi_list_security_material` | Safe user/OAuth/certificate identity and deployment metadata; credentials withheld. |
+| `cpi_set_user_credential` / `cpi_set_oauth2_client_credential` | Exact approved credential writes; values write-only. OAuth updates preserve omitted optional metadata and withhold upstream failure bodies. |
+| `cpi_upload_certificate` | Locally parse PEM X.509 before approved PUT; computed fingerprint differs from authoritative tenant read-back/trust evidence. |
+| `cpi_get_certificate_health` | Bounded validity-only assessment at a frozen evaluation time; no subject personal data or trust/connectivity inference. |
+| `cpi_get_operational_summary` | Bounded on-demand runtime/message/JMS/store/certificate signals with partial sources. No traffic/ordinary processing/backlog does not become healthy/degraded by inference. |
+| `cpi_list_number_ranges` / `cpi_set_number_range` | Read metadata or explicitly approve a named range change. |
+| `cpi_list_partner_parameters` / `cpi_set_partner_parameter` | Bounded string/binary metadata reads and separately approved named writes; do not edit TPM-generated data to simulate agreement management. |
+| `cpi_odata_get` | Safe implemented metadata roots/navigation/counts or `/$metadata` discovery only; no arbitrary functions, source, trace, payload or secret routes. |
+
+### API Management and Developer Hub
+
+| Tool | Behavior |
+|---|---|
+| `apim_list_api_providers` / `apim_get_api_provider` | Provider connection metadata with credential properties removed. |
+| `apim_create_api_provider` / `apim_update_api_provider` | Approved connection creation/change without backend credentials; credentialed updates and reserved names are refused. |
+| `apim_list_api_proxies` / `apim_get_api_proxy` / `apim_list_virtual_hosts` | Bounded metadata and computed runtime URL, preserving base-path separators and virtual-host ports. |
+| `apim_export_api_proxy` | Explicit authoring export of bundle files or one selected member. |
+| `apim_get_api_proxy_status` / `apim_inspect_api_proxy_security` | Safe observed state and private structural policy/attachment/condition/reference inspection; management/static evidence is not effective security or runtime health. |
+| `apim_create_api_proxy` / `apim_update_api_proxy` | Approved import/deploy, optionally secure the first revision; preserve unrelated resources and verify all intended content privately. Acceptance/content read-back/runtime identity remain separate. |
+| `apim_attach_api_proxy_policies` | Approved document replacement/missing assignment append, preserving omitted conditions; no implicit reorder/remove. |
+| `apim_edit_policy_steps` | Fresh bundle-digest-guarded complete order/conditions for one named endpoint/phase; inventory all references before explicit unreferenced-policy removal. |
+| `apim_get_api_documentation` / `apim_update_api_documentation` | Paginated OpenAPI structure or approved HTTPS-runtime-pinned documentation replacement/deploy/read-back, with only established portal normalization. |
+| `apim_get_analytics` / `apim_get_analytics_series` / `apim_get_api_error_breakdown` | Separate GA AnalyticsService aggregates/groups, weighted means and watermark for explicit UTC windows. Distinct derived aliases and source-record counts preserve valid empty null sums as no_data; input/group counts are not API calls. No fabricated percentiles/current health. |
+| `apim_list_api_products` / `apim_get_api_product` / `apim_create_api_product` / `apim_update_api_product` | Product metadata and approved creation/update; creation fixes proxy membership and publication does not grant OAuth authority. |
+| `apim_list_key_value_maps` / `apim_get_key_value_map` / `apim_create_key_value_map` / `apim_set_key_value_map_entries` | Map metadata/entry names and approved writes; values always withheld regardless of encryption representation. |
+| `apim_delete_api_product` / `apim_delete_api_proxy` / `apim_cleanup_api_objects` | Dependency-checked named removal or explicit-list dry-run-first cleanup. Deployed proxy removal needs permission; stop failed/unverified, never cascade into consumers/providers/KVMs/credentials. |
+| `apim_odata_get` | Implemented safe metadata projections/discovery, not arbitrary APIM administration or payload/source passthrough. |
+| `apim_test_api` | GET-only metadata/bounded entity probe, exactly one private API-key source (DEVHUB additionally required) or issuer-pinned named OAuth source (APIM alone). No redirects, arbitrary URLs, credentials or business row values. |
+| `devhub_list_developers` / `devhub_create_developer` / `devhub_approve_developer` | Registered developer metadata and separately approved onboarding/approval using Developer Hub authority. |
+| `devhub_list_applications` / `devhub_get_application` / `devhub_create_application` / `devhub_subscribe_application` | Safe application/subscription/key-availability metadata and approved consumer provisioning, without bypassing external governance. |
+| `devhub_list_subscriptions` | Bounded safe application/product/rate-plan IDs and subscription/approval evidence; legacy/incomplete relations explicit. |
+| `devhub_unsubscribe_application` | Exact approved dry-run-first subscription retirement, embedded batch status and fresh false subscription read-back; preserve actual relationship references. |
+| `devhub_delete_application` | Private short-lived single-use preview binds owner, both relationship inventories, tenant and active-subscription permission. Revalidate before one DELETE and named absence; no issued-token revocation claim. |
+
+### Separately credentialed optional components
+
+| Tools | Boundary |
+|---|---|
+| `ctms_list_nodes` | Public `/v2/nodes`, safe id/name local pages; upload/import eligibility remains unknown. No speculative gated upload/import/history adapter. |
+| `ans_list_subscriptions` / `ans_list_conditions` / `ans_list_action_metadata` | Native zero-based pages, safe metadata and canonical condition/subscription digests; private condition values/action properties/recipients withheld. |
+| `ans_validate_native_rules` | Full referenced-condition/action/fallback resolution and intentional event/node scope; delivery remains unverified. |
+| `ans_set_condition` / `ans_set_subscription` | Exact approved condition/subscription writes, fresh update digest or create absence, preserved omitted metadata and intended read-back. No arbitrary action-property writer/all-events subscription. |
+| `event_mesh_get_queue` | Exact encoded standalone default-plan named queue management metadata, no consumption/backlog health or Suite-embedded parity. |
+| `aem_list_brokers` / `aem_get_broker` / `aem_get_broker_operation` | Fixed US GA cloud metadata, one-based paging/documented expansions/observed states, no broker credentials/Beta/region fallback. |
+| `aem_list_queues` | Independent broker-local Basic/session, configured VPN monitor metadata and exact continuations. Unknown counts stay null; 529 means no session slots. |
+| `open_connectors_list_instances` / `open_connectors_get_instance` | Instance/element identity only; private pagination tokens, no configuration/provider data. |
+| `open_connectors_set_instance_enabled` | Fresh private scoped Element token for approved bodyless PUT/DELETE `/instances/enabled`; disable is not delete, acceptance is not effective state/provider health. |
+| `edge_get_api_metadata` / `edge_list_message_logs` / `edge_get_message_log` | Local Basic and preserved `/local` roots; safe discovery/shared MPL evidence. No raw schemas, component-status guesses, restart, shell/Kubernetes or payload access. |
+
+Confirmations are checked before network access but do not replace user approval. [Native lifecycle handoffs](tools.md#native-lifecycle-handoffs) cover Cloud ALM/ANS delivery, cTMS promotion, shared artifact creation/history, CPI queue controls/cancellation/design deletion, native APIM revisions/undeploy, consumer rotation/portal revoke, Suite Event Mesh, TPM, Advisor, Assessment/Migration and new Integration Cell API/MCP artifacts.
+
+Read-only connected verification: `node scripts/check-live-integration.mjs --window-minutes 60 --top 3 --json`. Its GET-only management guard is separate from the mutating `test:live:integration` runner. Missing optional credentials remain `live_unverified`; successful reads are not health, continuous delivery or native promotion proof.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-ai-dev-toolkit",
-  "version": "0.9.9918",
+  "version": "0.9.9920",
   "description": "SAP AI development toolkit for BAS, ABAP, RAP, CAP, HANA Cloud, Fiori, UI5, and MCP",
   "author": "Gurkan Yilmaz",
   "type": "module",