@raishin/vanguard-frontier-agentic 3.0.0-alpha.7 → 3.0.0

package/skills/sap/sap-guarded-transport-import/references/official-sources.md

@@ -0,0 +1,79 @@
+# Official sources — SAP Guarded Transport Import
+
+Use this reference when grounding SAP transport management commands, CTS+ API usage, STMS procedures, and Cloud TMS operations.
+
+**Evidence level**: documentation-based (SAP Help Portal). Live evidence gathered during steps 8 and 14 is labeled separately as `live evidence` per the audit format in `references/live-environment-access.md`.
+
+## SAP Cloud Transport Management Service
+
+- SAP Cloud Transport Management — what is SAP Cloud Transport Management
+  https://help.sap.com/docs/cloud-transport-management/sap-cloud-transport-management/what-is-sap-cloud-transport-management
+  source_owner: SAP SE
+  topic_supported: Cloud TMS architecture, transport nodes, transport routes, import queue management
+  why_needed: Authoritative source for Cloud TMS import sequence and transport node configuration used in steps 2, 7, 8, and 14
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- SAP Cloud TMS — transport nodes and routes
+  https://help.sap.com/docs/cloud-transport-management/sap-cloud-transport-management/transport-nodes-and-routes
+  source_owner: SAP SE
+  topic_supported: Transport node types (source, target, virtual), transport route configuration, import queue management per node
+  why_needed: Defines the node and route model — required to assess blast radius (step 10) and target system scope (step 2 and 7)
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- SAP Cloud TMS — importing transport requests
+  https://help.sap.com/docs/cloud-transport-management/sap-cloud-transport-management/importing-transport-requests
+  source_owner: SAP SE
+  topic_supported: Import process flow, import log interpretation, error handling and rollback in Cloud TMS
+  why_needed: Grounds step 15 (verify) and step 11 (rollback plan) with Cloud TMS-specific recovery procedures
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- SAP Cloud TMS — Transport Management System integration
+  https://help.sap.com/docs/cloud-transport-management/sap-cloud-transport-management/transport-management-system-integration
+  source_owner: SAP SE
+  topic_supported: Integration of Cloud TMS with on-premise STMS, CTS+ configuration, RFC destination setup for hybrid landscapes
+  why_needed: Authoritative reference for hybrid landscape scenarios where Cloud TMS fronts an ABAP STMS backend — relevant for steps 2 and 7 target classification
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- SAP Cloud TMS — segregation of duties in transport management
+  https://help.sap.com/docs/cloud-transport-management/sap-cloud-transport-management/segregation-of-duties-in-transport-management
+  source_owner: SAP SE
+  topic_supported: SoD controls in Cloud TMS, role separation between transport requester and transport approver/importer, Cloud TMS role definitions
+  why_needed: Authoritative reference for step 12 (SoD check) — defines the Cloud TMS role model and how requester/approver/importer separation must be verified
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## ABAP Platform Transport Management (STMS / CTS+)
+
+- ABAP Platform — Transport Organizer and STMS
+  https://help.sap.com/docs/abap-platform/abap-platform/transport-organizer-and-stms
+  source_owner: SAP SE
+  topic_supported: STMS configuration, transport route management, import queue operations, authorization objects for transport management
+  why_needed: Authoritative source for STMS import procedures, authorization object requirements (S_TRANSPRT), and import log reading used in steps 8, 12, 14, and 15
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Change Management Integration
+
+- SAP Solution Manager — change request management
+  https://help.sap.com/docs/sap-solution-manager/sap-solution-manager/change-request-management
+  source_owner: SAP SE
+  topic_supported: Change request management (ChaRM) integration with transport management; ticket linkage for step 6; SoD enforcement patterns
+  why_needed: Grounds step 6 (ticket linkage) and step 12 (SoD verification) with SAP-native change management integration context
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- BTP change management
+  https://help.sap.com/docs/btp/sap-business-technology-platform/change-management-in-sap-btp
+  source_owner: SAP SE
+  topic_supported: Change management controls for BTP-hosted services and configurations; approval workflows
+  why_needed: Relevant for steps 5, 12, and 13 when transport targets include BTP subaccount configurations alongside ABAP transports
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Grounding rule
+
+SAP Help Portal documentation describes transport management design intent, authorization object requirements, and API specifications. It does not prove which transport routes exist in the user's landscape, which SAP systems are accessible, what the current import queue contains, or whether the user's STMS is configured for the described procedures. Users must supply live evidence from steps 8 and 15 for concrete transport assessment.

package/skills/sap/sap-guarded-transport-import/references/safety-checklist.md

@@ -0,0 +1,52 @@
+# Safety checklist — SAP Guarded Transport Import
+
+Use before every step and unconditionally before step 14 execution.
+
+## Non-negotiables
+
+- Do not reach step 14 (execute) without a documented approval from an authorized approver on record in this session.
+- Do not allow self-approval. The requester (step 4) and the approver (step 5) must be different individuals. If they are the same, refuse execution.
+- Do not import transport requests not on the approved TR list from step 7.
+- Do not skip or reorder steps. The sequence is mandatory.
+- Do not use BASIS administrator credentials. Use a transport administrator role scoped to the target system only.
+- Do not accept, log, echo, or include ABAP logon passwords, STMS service user passwords, CTS+ service key credential values, or Cloud TMS OAuth tokens in any output.
+- Do not attempt self-recovery after a failed import without initiating a new 17-step sequence.
+- Do not import into a production system without a documented rollback plan (step 11).
+
+## What people get wrong
+
+- **Treating verbal approval as sufficient**: Step 13 requires explicit written approval documented in the session. Verbal or assumed approval does not clear the gate.
+- **Assuming DEV → QA imports are low risk**: QA systems run integrated testing and UAT. Imports into QA must follow the full sequence.
+- **Batching multiple TRs without per-TR classification**: Each transport request must appear in step 7 with its description. Batch importing unlisted TRs is forbidden.
+- **Using the wrong user for import**: The import user must have S_TRANSPRT authorization for the target system. A developer user or BASIS admin is not appropriate.
+- **Skipping step 9 because "it's a config transport"**: Configuration transports can overwrite production settings. Diff and dry-run are mandatory regardless of transport type.
+- **Not documenting the blast radius for customizing transports**: Customizing transports (client-specific) can affect system-wide business process settings. Blast radius must include affected business processes, not just ABAP objects.
+- **Proceeding after a WARNING in the import log**: WARNING entries in STMS/Cloud TMS import logs can indicate partial failures. Step 15 must assess every WARNING before the session is closed.
+
+## When to push back
+
+- Push back when the user asks to "just run the import" without completing prior steps.
+- Push back when the requester and approver are the same person.
+- Push back when no change management ticket number is provided.
+- Push back when the rollback plan is "we'll figure it out if something goes wrong."
+- Push back when the import target is production and no dry-run or diff has been performed.
+- Push back when the user provides a credential with more than transport-administrator scope (e.g., BASIS admin, SAP_ALL).
+- Push back when post-import verification (step 15) shows errors and the user wants to proceed without assessment.
+
+## Evidence labels
+
+- `live evidence` — directly observed from a live SAP system; include command, timestamp, system SID
+- `documentation-based` — grounded in SAP official docs; no live access
+- `user-provided evidence` — stated, uploaded, or confirmed by the user in this session
+- `inference` — derived reasoning; must always be labeled as such
+
+## SoD verification matrix
+
+| Role | Can request? | Can approve? |
+|------|-------------|-------------|
+| Developer (Z-developer role) | Yes | No |
+| Functional consultant | Yes | No |
+| Change manager | No | Yes |
+| Basis administrator | No | Yes (for technical approval only) |
+| Project manager | No | Yes |
+| Developer and change manager in same person | No — SoD violation | Refuse execution |

package/skills/sap/sap-guarded-transport-import/references/workflow-and-output.md

@@ -0,0 +1,93 @@
+# Workflow and output contract — SAP Guarded Transport Import
+
+Use this reference for all step-by-step execution, command patterns, and output formatting.
+
+## Step execution protocol
+
+For each of the 17 steps, the following must be true before advancing to the next:
+
+1. The step's required evidence is on record in this session.
+2. The user has confirmed the evidence is accurate.
+3. Any step-specific gate (e.g., approval, SoD check) has been explicitly cleared.
+
+If any of these conditions is false, the session pauses at the current step until resolved.
+
+## Command patterns by step
+
+### Step 8 — Read-only current state
+
+#### STMS (ABAP)
+```
+Display import queue: transaction STMS → Import Overview → select target system
+Display transport log: transaction STMS → Transport Logs → filter by TR number
+RFC call (read-only): CTS_API_GET_COFILE or equivalent display FM
+```
+
+#### CTS+ API (read)
+```
+GET /cts/transports/{transportId}
+GET /cts/systems/{systemId}/importqueue
+```
+
+#### Cloud TMS API (read)
+```
+GET /v2/nodes/{nodeId}/transportRequests
+GET /v2/importqueue/{nodeId}
+GET /v2/nodes/{nodeId}/deployments/{deploymentId}
+```
+
+### Step 14 — Execute approved import
+
+#### STMS (ABAP)
+```
+Transaction STMS → Import Overview → select target system → import approved TR only
+Authorization check: user must have S_TRANSPRT with ACTVT=42 (import) for target system
+```
+
+#### Cloud TMS API (mutating — step 14 only, after step 13 gate is cleared)
+```
+POST /v2/nodes/{nodeId}/transportRequests/{trId}/deploy
+Body: { "description": "<ticket reference from step 6>", "versionStrategy": "PICK_ALL_MATCHING_COMMITS" }
+```
+
+**Never call the POST endpoint before step 13 approval gate is documented.**
+
+## Step completion checklist
+
+| Step | Evidence type | Completion marker |
+|------|--------------|------------------|
+| 1 | user-provided / documentation-based | Transport type and content category confirmed |
+| 2 | user-provided evidence | Target SID, client, tier confirmed |
+| 3 | user-provided evidence | Criticality level assigned |
+| 4 | user-provided evidence | Requester name and role on record |
+| 5 | user-provided evidence | Approver name, role, and identity on record |
+| 6 | user-provided evidence | Ticket number confirmed |
+| 7 | user-provided evidence | TR list with descriptions and sequence on record |
+| 8 | live evidence | Current state snapshot from target system |
+| 9 | live evidence or documented exception | Diff output or dry-run result |
+| 10 | user-provided / inference | Blast radius document confirmed |
+| 11 | user-provided evidence | Rollback procedure confirmed feasible |
+| 12 | user-provided evidence | SoD confirmed: requester ≠ approver |
+| 13 | user-provided evidence | Explicit approval statement on record |
+| 14 | live evidence | Import command log with timestamp |
+| 15 | live evidence | Import log verified, smoke test result |
+| 16 | all of the above | Audit record compiled |
+| 17 | user-provided evidence | Report delivered and acknowledged |
+
+## Output contract
+
+Return after each step:
+
+1. Step number and name
+2. Evidence gathered for this step (labeled by evidence type)
+3. Gate status: cleared / pending / blocked
+4. Next step and what is needed to advance
+5. Refusal marker if any gate condition is unmet (do not advance)
+
+Return after step 17:
+
+1. Complete audit record (all 17 steps with evidence and timestamps)
+2. Final import status (success / partial / failed)
+3. Post-import verification result
+4. Rollback status (not needed / standing by / triggered)
+5. Report delivery confirmation

package/skills/sap/sap-hana-cloud-performance-cost/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: sap-hana-cloud-performance-cost
+description: Review SAP HANA Cloud performance and cost posture: instance sizing and elasticity, performance modeling (column store, indexes, partitioning, query execution plans), cost management (compute and storage scaling, auto-stop, tier selection), and monitoring (expensive statements, thread sampling, workload classes). Flags sizing risks, modeling anti-patterns, cost governance gaps, and monitoring blind spots. Does not touch live systems.
+allowed-tools: Read Grep Glob WebSearch WebFetch
+metadata:
+  author: "github: Raishin"
+  version: "0.1.0"
+  updated: "2026-06-19"
+  category: data
+  lifecycle: experimental
+---
+
+# SAP HANA Cloud Performance and Cost Review
+
+## Purpose
+
+Assess the performance architecture and cost governance posture of an SAP HANA Cloud implementation. Review instance sizing and elasticity configuration, data modeling for performance (column store vs. row store usage, partitioning strategy, index design, materialized views), query execution plan analysis (EXPLAIN PLAN, SQL Plan Cache, expensive statement trace), cost management controls (compute scaling, storage tier selection, auto-stop configuration), and monitoring coverage (workload classes, thread sampling, key performance views). Surface sizing risks, data modeling anti-patterns, query performance bottlenecks, cost governance gaps, and monitoring blind spots. Does not connect to or mutate any live HANA Cloud instance.
+
+## When to use
+
+Use this skill when the user asks to:
+
+- review HANA Cloud instance sizing decisions (vCPU, memory, storage) against workload characteristics and expected concurrency,
+- assess elasticity configuration: scale-out node design, dynamic tiering, compute unit auto-scaling, and scheduled scaling for predictable peak loads,
+- evaluate column store data modeling decisions: table partitioning (range, hash, round-robin), sort-column selection for delta compression, index type selection (inverted index, composite inverted index, full text index), and row store vs. column store table type choices,
+- analyze SQL query execution plans using EXPLAIN PLAN output, SQL Plan Cache entries, or expensive statement trace results provided by the user,
+- review SQLScript stored procedure design for performance: cursor vs. set-based logic, tabular function use, plan stability, and SQLSCRIPT PLAN PROFILER findings,
+- assess cost management configuration: HANA Cloud instance compute tier selection, storage auto-scaling thresholds, auto-stop schedule for non-production instances, and data tiering (hot/warm/cold via SAP HANA Native Storage Extension or Data Lake),
+- review monitoring posture: expensive statement trace configuration, workload class definition, thread sampling setup, and key performance views (M_EXPENSIVE_STATEMENTS, M_SQL_PLAN_CACHE, M_LOAD_HISTORY_SERVICE) coverage,
+- flag HANA Cloud performance anti-patterns: missing table partitioning on large tables, cursor-based SQLScript that can be rewritten as set-based, missing delta merge schedule, or non-production instances without auto-stop.
+
+## When not to use
+
+- When the user needs live inspection of a running HANA Cloud instance, live system views, or query plan output from an active connection — this skill accepts only user-provided EXPLAIN PLAN output, trace exports, monitoring screenshots, or architecture descriptions.
+- When the request is about Datasphere semantic modeling or data product architecture built on top of HANA Cloud — use `sap-datasphere-data-product-architecture`.
+- When the request is about SAP Analytics Cloud models connected to HANA Cloud via live connection — use `sap-analytics-cloud-planning-governance` for the SAC side.
+- When the request concerns BTP-level entitlement or capacity governance for the HANA Cloud service instance — use `sap-btp-governance-review`.
+
+## Does not touch live systems
+
+This skill operates on user-provided descriptions, EXPLAIN PLAN output, SQL Plan Cache exports, expensive statement trace results, architecture documents, monitoring screenshots, or written descriptions of the HANA Cloud configuration. It does not connect to any HANA Cloud instance, execute SQL, invoke HANA Cloud APIs, access the SAP HANA Cloud Central console, or access any connected source or consumer system. All live inspection is out of scope.
+
+## Lean operating rules
+
+- Classify findings before recommending. Every finding must be assigned to a review domain (sizing and elasticity, data modeling, query performance, SQLScript, cost management, monitoring) before remediation is proposed.
+- Column store is the default for analytic workloads; row store is for high-throughput transactional lookups on small tables. Every table type choice must be justified by workload type. Column store tables on high-frequency single-row OLTP paths, and row store tables on large analytic scan workloads, are both architectural risks.
+- Partitioning is required for large tables. HANA Cloud tables exceeding 2 billion rows require partitioning. Tables between 100 million and 2 billion rows benefit significantly from partitioning for parallel scan performance. The absence of partitioning on large column store tables is a `high` performance finding.
+- EXPLAIN PLAN analysis must account for column store hints. HANA Cloud query optimizer decisions can be influenced by hints (CS_ALL_COLUMNS, NO_CS_JOIN, USE_HEX_PLAN). EXPLAIN PLAN output that shows unexpectedly high row-store operator usage warrants a hint review before indexing changes.
+- SQLScript cursor loops over column store tables are a performance anti-pattern. Row-at-a-time cursor processing in SQLScript forces row engine execution on column store data, bypassing the column engine parallel scan. Set-based rewrite is always preferred.
+- Auto-stop is mandatory for non-production HANA Cloud instances. HANA Cloud compute is billed per running time. Non-production instances without auto-stop configuration accrue avoidable compute cost during idle periods.
+- Workload classes are required for multi-tenant cost and resource governance. Without workload class definitions, all queries compete for HANA resources without priority or resource limits, making production workload isolation impossible.
+- Evidence from user-provided EXPLAIN PLAN output, trace files, or architecture descriptions takes precedence over inference. Context7 HANA Cloud documentation supplements official SAP Help Portal docs for SQL and SQLScript specifics.
+- Load only the reference needed for the component under review.
+
+## Evidence rules
+
+Label all claims with one of:
+
+- `documentation-based` — grounded in SAP HANA Cloud Help Portal documentation or official SAP HANA Cloud administration and SQL reference guides
+- `user-provided evidence` — EXPLAIN PLAN output, SQL Plan Cache exports, expensive statement trace results, monitoring screenshots, or architecture descriptions provided by the user
+- `context7-supplementary` — grounded in SAP HANA Cloud SQL reference or SQLScript documentation fetched from Context7 (supplementary; applies when SQL statement-level or SQLScript procedure-level guidance is in scope)
+- `inference` — derived reasoning not directly confirmed by official docs or user evidence
+
+## Live-environment rules
+
+**This skill does not touch live systems.** There is no HANA Cloud SQL connection, instance API call, HANA Cloud Central console access, system view query, or SQLScript execution in this skill's execution path. Users must supply EXPLAIN PLAN output, SQL Plan Cache exports, expensive statement trace results, monitoring view query results, or written descriptions of their HANA Cloud implementation for this skill to review.
+
+## References
+
+Load only when needed:
+
+- [Workflow and output contract](references/workflow-and-output.md) — review domain taxonomy, finding severity, output format.
+- [Safety checklist](references/safety-checklist.md) — non-negotiables, common mistakes, when to push back.
+- [Official sources](references/official-sources.md) — SAP HANA Cloud sizing, modeling, partitioning, indexing, cost management, SQLScript, and monitoring docs.
+- [Context7 framework docs](references/context7-framework-docs.md) — SAP HANA Cloud SQL and SQLScript reference for EXPLAIN PLAN, plan profiler, and column store hint guidance (supplementary; use when SQL statement or SQLScript procedure analysis is in scope).
+
+## Response minimum
+
+Return, at minimum:
+
+- **Problem classification**: review domain(s) affected (sizing and elasticity / data modeling / query performance / SQLScript / cost management / monitoring) and specific finding(s).
+- **Evidence used**: documentation-based / user-provided evidence / context7-supplementary / inference.
+- **Risk level**: critical (data loss risk or production availability risk from sizing failure) / high (performance bottleneck or uncontrolled cost accumulation) / medium (governance gap or monitoring blind spot) / low (best practice deviation).
+- **Recommended action**: specific remediation per finding (partitioning strategy, index addition or removal, EXPLAIN PLAN hint, SQLScript rewrite guidance, auto-stop configuration, workload class definition, or monitoring view addition).
+- **Refusal / escalation triggers**: if live HANA Cloud instance access, SQL execution, or system view query is required to complete the review, state that clearly and do not proceed.
+- **Business impact**: production availability risk, query timeout risk, uncontrolled cost overrun, data access performance degradation, or monitoring gap leading to silent incidents.
+- **Next verification step**: validate recommended changes against the current HANA Cloud instance configuration and execute EXPLAIN PLAN on the modified query or table before applying changes to production.

package/skills/sap/sap-hana-cloud-performance-cost/agents/openai.yaml

@@ -0,0 +1,11 @@
+interface:
+  display_name: "SAP HANA Cloud Performance and Cost Review"
+  short_description: "Review SAP HANA Cloud performance and cost posture: instance sizing, column store modeling, partitioning, indexes, query execution plans, SQLScript design, cost management controls, and monitoring coverage. Flags sizing risks, modeling anti-patterns, and cost governance gaps."
+  default_prompt: "Use $sap-hana-cloud-performance-cost to assess the provided SAP HANA Cloud implementation. Classify each finding by review domain (sizing and elasticity, data modeling, query performance, SQLScript, cost management, monitoring), assign a risk level (critical/high/medium/low), and recommend specific remediation actions. State evidence level (documentation-based, user-provided evidence, context7-supplementary, inference) and whether live instance access is required to complete the review."
+dependencies:
+  tools:
+    - type: "web"
+      value: "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-performance-guide/analyzing-sql-execution-plans"
+      description: "SAP HANA Cloud SQL execution plan analysis documentation — primary reference for EXPLAIN PLAN and SQL Plan Cache performance review"
+policy:
+  allow_implicit_invocation: true

package/skills/sap/sap-hana-cloud-performance-cost/metadata.json

@@ -0,0 +1,33 @@
+{
+  "id": "sap-hana-cloud-performance-cost",
+  "name": "SAP HANA Cloud Performance and Cost Review",
+  "type": "skill",
+  "provider": "sap",
+  "harnesses": [
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini",
+    "kiro",
+    "other"
+  ],
+  "summary": "Review SAP HANA Cloud performance and cost posture: instance sizing, elasticity, column store modeling, partitioning, indexes, query execution plans, SQLScript design, cost management controls (auto-stop, data tiering, compute scaling), and monitoring coverage. Flags sizing risks, modeling anti-patterns, and cost governance gaps. Does not access live systems.",
+  "source_type": "original",
+  "category": "data",
+  "official_docs": [
+    "https://help.sap.com/docs/hana-cloud/sap-hana-cloud-getting-started-guide/sizing-sap-hana-cloud",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/table-partitioning",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/indexes",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-performance-guide/analyzing-sql-execution-plans",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-sqlscript-reference/sap-hana-cloud-sap-hana-database-sqlscript-reference",
+    "https://help.sap.com/docs/hana-cloud/sap-hana-cloud-getting-started-guide/managing-sap-hana-cloud",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/workload-management",
+    "https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-performance-guide/monitoring-performance"
+  ],
+  "security_notes": "Does not access live SAP HANA Cloud instances, execute SQL, invoke HANA Cloud APIs, or access HANA Cloud Central console. Accepts only user-provided EXPLAIN PLAN output, SQL Plan Cache exports, expensive statement trace results, monitoring screenshots, or written descriptions. Never request or accept HANA Cloud instance credentials, database user credentials, SQL user passwords, or connection strings. Performance and cost recommendations must be validated against the live instance configuration and tested before production deployment.",
+  "last_verified": "2026-06-19",
+  "path": "skills/sap/sap-hana-cloud-performance-cost",
+  "author": "github: Raishin",
+  "version": "0.1.0",
+  "lifecycle": "experimental"
+}

package/skills/sap/sap-hana-cloud-performance-cost/references/context7-framework-docs.md

@@ -0,0 +1,94 @@
+# Context7 framework docs — SAP HANA Cloud Performance and Cost Review
+
+**Role**: supplementary. Official SAP HANA Cloud Help Portal documentation is the primary source for all sizing, modeling, and performance review guidance. Context7-sourced SAP HANA Cloud documentation supplements guidance specifically for SQL statement-level and SQLScript procedure-level analysis — EXPLAIN PLAN syntax, execution plan operator interpretation, SQLScript plan profiler commands, and column store optimizer hints.
+
+**Library used**: SAP HANA Cloud  
+Context7 library ID: `/sap-archive/sap-hana-cloud-hana-database`  
+Lookup target: EXPLAIN PLAN syntax, SQL Plan Cache queries, SQLScript PLAN PROFILER, column store optimizer hints, row store vs. column store operator behavior  
+Skill: `sap-hana-cloud-performance-cost`  
+Classification: supplementary
+
+---
+
+## EXPLAIN PLAN for SQL execution plan analysis (supplementary)
+
+Source: SAP HANA Cloud SQL Reference (Context7 `/sap-archive/sap-hana-cloud-hana-database`)
+
+The EXPLAIN PLAN statement captures the optimizer's execution plan for a SQL query without executing it. The captured plan is written to the EXPLAIN_PLAN_TABLE system view, queryable by STATEMENT_NAME. This is used to identify suboptimal access paths (row engine operations on column store tables, missing partition pruning, or cartesian joins) from user-provided query text.
+
+```sql
+DELETE FROM explain_plan_table WHERE statement_name = 'MY_QUERY';
+
+EXPLAIN PLAN SET STATEMENT_NAME = 'MY_QUERY' FOR
+  SELECT * FROM SALES_FACT SF
+  JOIN CUSTOMER DIM ON SF.CUSTOMER_ID = DIM.CUSTOMER_ID
+  WHERE SF.POSTING_DATE >= '2025-01-01';
+
+SELECT operator_name, operator_details, table_name
+  FROM explain_plan_table
+  WHERE statement_name = 'MY_QUERY';
+```
+
+**Relevance to performance review**: When the user provides a slow query, the EXPLAIN PLAN output (or the equivalent SQL Plan Cache entry) is the primary artifact for classifying query performance findings. Key signals to look for:
+- `ROW SEARCH` operator on a large column store table indicates row engine forced execution — likely caused by a data type mismatch in the join predicate or an explicit `WITH HINT(COLUMN_VIEW_AS_ROW_TABLE)`.
+- Missing `COLUMN SEARCH` operator on the primary filter column indicates the optimizer did not use the column store scan path.
+- `HASH JOIN` on a very large outer table without partition pruning indicates a missing or non-selective partition key.
+
+## SQLScript Plan Profiler for procedure performance (supplementary)
+
+Source: SAP HANA Cloud system management statements (Context7 `/sap-archive/sap-hana-cloud-hana-database`)
+
+The SQLScript Plan Profiler captures execution statistics for individual SQLScript procedure steps. It can be activated for a specific session or a specific procedure to isolate which steps within a complex procedure consume the most time. This is the correct tool for diagnosing performance issues inside SQLScript procedures when the overall procedure execution time is unacceptably high.
+
+```sql
+-- Start profiling a specific procedure
+ALTER SYSTEM START SQLSCRIPT PLAN PROFILER FOR PROCEDURE MYSCHEMA.MY_PROC;
+
+-- Execute the procedure to capture profiling data
+CALL MYSCHEMA.MY_PROC();
+
+-- Stop the profiler
+ALTER SYSTEM STOP SQLSCRIPT PLAN PROFILER;
+
+-- Query profiler results to identify expensive steps
+SELECT * FROM M_SQLSCRIPT_PLAN_PROFILERS;
+```
+
+**Relevance to performance review**: When the user provides SQLScript procedure code that is suspected to contain a cursor-based anti-pattern or an expensive intermediate step, the SQLSCRIPT PLAN PROFILER is the recommended tool to confirm which specific step dominates execution time before recommending a rewrite. Without profiler data, procedure performance recommendations are classified as `inference`.
+
+## Column store optimizer hints for access path control (supplementary)
+
+Source: SAP HANA Cloud hint reference (Context7 `/sap-archive/sap-hana-cloud-hana-database`)
+
+HANA Cloud's query optimizer selects between column engine and row engine execution paths based on its cost model. In some cases the optimizer's estimates differ from actual performance due to stale statistics or skewed data distributions. Optimizer hints can override the access path decision for a specific query or plan cache entry.
+
+Key hints for column store performance review:
+
+- `CS_ALL_COLUMNS`: Forces the optimizer to use the column store for all table accesses in the query. Use when EXPLAIN PLAN shows unexpected row engine access on a large column store table.
+- `NO_CS_JOIN`: Prohibits the column engine from executing the join. Use only when the column engine join is demonstrably slower than a row engine join (rare; typically only for very small tables).
+- `USE_HEX_PLAN`: Forces use of the hexagonal (HEX) join engine plan for complex multi-table joins. The HEX engine can outperform the classic join engine for star schema queries with multiple large fact-to-dimension joins.
+
+Example of applying a hint in a query:
+
+```sql
+SELECT /* CS_ALL_COLUMNS */ SF.POSTING_DATE, SUM(SF.AMOUNT)
+FROM SALES_FACT SF
+JOIN CUSTOMER DIM ON SF.CUSTOMER_ID = DIM.CUSTOMER_ID
+GROUP BY SF.POSTING_DATE;
+```
+
+**Relevance to performance review**: When a user provides EXPLAIN PLAN output showing unexpected row engine operator usage on a column store table, the access path hint guidance above is applied as `context7-supplementary` evidence. The recommended hint must be validated against a fresh EXPLAIN PLAN run on the user's system — hints are advisory supplements, not guaranteed fixes without execution plan confirmation.
+
+---
+
+## Scope boundaries for Context7 usage
+
+Context7 SAP HANA Cloud documentation applies **only** for SQL statement-level and SQLScript procedure-level analysis where the user has provided query text, EXPLAIN PLAN output, SQL Plan Cache data, or SQLScript code. It does not apply to:
+
+- HANA Cloud instance sizing decisions — use SAP HANA Cloud Getting Started Guide (official docs)
+- Table partitioning design — use SAP HANA Cloud Database Administration Guide (official docs)
+- Index type selection — use SAP HANA Cloud Database Administration Guide (official docs)
+- Workload class and resource limit configuration — use SAP HANA Cloud Database Administration Guide (official docs)
+- Auto-stop and compute scaling — use HANA Cloud Central documentation (official docs)
+
+Always label Context7-sourced guidance as `context7-supplementary` in responses.

package/skills/sap/sap-hana-cloud-performance-cost/references/official-sources.md

@@ -0,0 +1,83 @@
+# Official sources — SAP HANA Cloud Performance and Cost Review
+
+Use this reference when grounding HANA Cloud sizing, data modeling, query performance, SQLScript design, cost management, and monitoring assessments.
+
+**Evidence level**: documentation-based (SAP HANA Cloud Help Portal). No live-system evidence is collected by this skill.
+
+## Sizing and instance management
+
+- Sizing SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud/sap-hana-cloud-getting-started-guide/sizing-sap-hana-cloud
+  source_owner: SAP SE
+  topic_supported: HANA Cloud instance sizing guidance, vCPU and memory tier selection, sizing rules for in-memory footprint, disk storage sizing, and elasticity configuration
+  why_needed: Primary reference for classifying sizing findings including under-provisioned memory for in-memory workloads, incorrectly sized compute tiers, and absent elasticity configuration for variable workloads
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- Managing SAP HANA Cloud instances
+  https://help.sap.com/docs/hana-cloud/sap-hana-cloud-getting-started-guide/managing-sap-hana-cloud
+  source_owner: SAP SE
+  topic_supported: HANA Cloud Central instance management, auto-stop configuration, compute scaling (scale-up, scale-out), storage auto-scaling, instance lifecycle governance
+  why_needed: Defines auto-stop and compute scaling controls — required to classify non-production instances without auto-stop and uncontrolled compute scaling as cost governance findings
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Data modeling
+
+- Table partitioning in SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/table-partitioning
+  source_owner: SAP SE
+  topic_supported: Partitioning types (range, hash, round-robin, multilevel), partition key selection, partition pruning behavior, partition count guidelines for large tables
+  why_needed: Defines the partitioning model — required to classify missing partitioning on large column store tables as a performance finding and to assess partition key selection for pruning effectiveness
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- Indexes in SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/indexes
+  source_owner: SAP SE
+  topic_supported: Index types (inverted index, composite inverted index, full text index), column store implicit primary key index, index usage in query execution plans, when indexes improve vs. hurt column store performance
+  why_needed: Defines the index model for HANA Cloud column store — required to assess index design decisions, identify redundant indexes that increase DML overhead, and evaluate whether missing indexes are causing full-scan performance issues
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Query performance
+
+- Analyzing SQL execution plans in SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-performance-guide/analyzing-sql-execution-plans
+  source_owner: SAP SE
+  topic_supported: EXPLAIN PLAN statement usage, SQL Plan Cache analysis, plan operator interpretation (column search, row search, join engine), identifying plan regressions, optimizer hints for access path control
+  why_needed: Primary reference for interpreting user-provided EXPLAIN PLAN output and SQL Plan Cache data — required to classify query plan issues (wrong join engine, missing column search, suboptimal access path) as performance findings
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+- Monitoring performance in SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-performance-guide/monitoring-performance
+  source_owner: SAP SE
+  topic_supported: Expensive statement trace configuration, M_EXPENSIVE_STATEMENTS view, thread sampling, M_SQL_PLAN_CACHE, M_LOAD_HISTORY_SERVICE, workload analysis monitoring views
+  why_needed: Defines the monitoring model — required to classify missing expensive statement trace configuration, absent thread sampling, and no workload class monitoring as monitoring blind spot findings
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## SQLScript
+
+- SAP HANA Cloud SQLScript reference
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-sqlscript-reference/sap-hana-cloud-sap-hana-database-sqlscript-reference
+  source_owner: SAP SE
+  topic_supported: SQLScript language reference, tabular functions, scalar functions, cursor vs. set-based logic, SQLSCRIPT PLAN PROFILER, procedure call stack analysis
+  why_needed: Defines the SQLScript execution model — required to classify cursor-based anti-patterns, missing tabular function use for reusable logic, and procedure plan stability issues as SQLScript performance findings
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Cost management and data tiering
+
+- Workload management in SAP HANA Cloud
+  https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-administration-guide/workload-management
+  source_owner: SAP SE
+  topic_supported: Workload class definition, workload mapping rules, resource limits (CPU, memory, query timeout) per workload class, priority-based execution scheduling
+  why_needed: Defines the workload governance model — required to classify missing workload class definitions, absent resource limits, and unmanaged query concurrency as cost and resource governance findings
+  evidence_level: primary
+  last_verified: 2026-06-19
+
+## Grounding rule
+
+SAP HANA Cloud Help Portal documentation describes the designed behavior of column store tables, partitioning strategies, index types, SQL execution plans, SQLScript procedures, and cost management controls. It does not prove which tables exist in the user's instance, what execution plans are currently active, or whether auto-stop is configured. Users must supply EXPLAIN PLAN output, SQL Plan Cache exports, trace results, monitoring view query outputs, or written descriptions for concrete assessment.

package/skills/sap/sap-hana-cloud-performance-cost/references/safety-checklist.md

@@ -0,0 +1,36 @@
+# Safety checklist — SAP HANA Cloud Performance and Cost Review
+
+Use before making any remediation recommendation, especially for findings that affect production instance sizing, table partitioning, index changes, or SQLScript procedure rewrites.
+
+## Non-negotiables
+
+- Do not access, connect to, or request access to any live HANA Cloud instance, execute SQL statements, invoke HANA Cloud APIs, or access HANA Cloud Central. This skill reviews artifacts only.
+- Do not accept or request HANA Cloud instance credentials, database user credentials, SQL user passwords, connection strings, service keys, or OAuth tokens for any HANA Cloud instance.
+- Do not recommend online partitioning or index changes on a production HANA Cloud table without first confirming the table size, active connections, and whether a maintenance window is available. Online ALTER TABLE operations for partitioning on large tables consume significant resources and can affect production query performance during execution.
+- Do not recommend scaling down a HANA Cloud instance (reducing memory or vCPU) without first confirming current and peak memory utilization from M_LOAD_HISTORY_SERVICE data. Scaling down below the working memory requirement of the currently loaded data causes immediate out-of-memory failures.
+- Do not recommend enabling auto-stop on an instance that may be serving production workloads. Auto-stop is appropriate only for explicitly non-production instances. Confirm the instance role with the user before recommending auto-stop.
+- Do not recommend SQLScript procedure rewrites on production procedures without a development-environment test and SQLSCRIPT PLAN PROFILER validation of the rewritten procedure's execution plan.
+- Do not classify a finding as `critical` without being able to trace the specific availability risk, data loss scenario, or resource exhaustion path from user-provided evidence or official documentation.
+
+## What people get wrong
+
+- **Recommending column store indexes as the default solution for slow queries**: HANA Cloud column store is designed for full-column scans using SIMD-based compression. Adding an inverted index on a column store table improves performance only for highly selective single-value lookups. For range scans and aggregations, indexes on column store tables often have no positive effect and increase DML overhead. EXPLAIN PLAN analysis must confirm whether an index would actually be used before recommending it.
+- **Confusing HANA Cloud scale-out nodes with dynamic tiering**: HANA Cloud scale-out adds additional in-memory processing nodes for horizontal partitioning and workload distribution. Dynamic tiering (NSE warm store) moves infrequently accessed data to disk storage within the same instance. They address different problems — scale-out for data volume and concurrency; tiering for cost reduction on cold data.
+- **Applying HANA Platform on-premise performance guidance directly to HANA Cloud**: Some HANA Platform on-premise recommendations (manual delta merge tuning, specific internal parameter changes) are either not applicable or not user-configurable in HANA Cloud. HANA Cloud manages many internal parameters automatically. Recommending parameter changes that are not user-accessible in HANA Cloud is incorrect.
+- **Treating all cursor-based SQLScript as an anti-pattern**: Cursors in SQLScript are appropriate for row-by-row business logic that genuinely requires procedural iteration (sequential number generation, row-dependent conditional branching). The anti-pattern is using a cursor to iterate over large column store result sets when the same result can be achieved with a set-based INSERT INTO ... SELECT. Not every cursor is a performance problem.
+- **Recommending workload class changes without confirming existing class bindings**: Workload classes apply to mapped users and application connections. Recommending new resource limits on an existing workload class without confirming which users and applications are currently mapped to it risks applying resource throttling to unintended production workloads.
+- **Missing the plan cache invalidation risk from UPDATE STATISTICS**: Updating table statistics triggers SQL Plan Cache invalidation for all queries referencing the updated table. On a busy production system this can cause a temporary plan recompilation storm. UPDATE STATISTICS on large production tables should be executed during low-traffic windows.
+
+## When to push back
+
+- Push back when the user asks to confirm a query performance finding without providing EXPLAIN PLAN output, SQL Plan Cache data, or expensive statement trace results.
+- Push back when the user asks for specific memory sizing numbers without providing current M_LOAD_HISTORY_SERVICE utilization data or a workload description with concurrency and data volume details.
+- Push back when the user asks to recommend changes to production tables (partitioning, indexing) without confirming current table size, active connections, and maintenance window availability.
+- Push back when a request requires live HANA Cloud instance access, SQL execution, or system view query — state clearly that live inspection is out of scope and ask the user to supply the relevant outputs or descriptions.
+
+## Evidence labels
+
+- `documentation-based` — grounded in SAP HANA Cloud Help Portal documentation covering sizing, modeling, partitioning, indexes, SQL execution plans, SQLScript, cost management, or monitoring
+- `user-provided evidence` — EXPLAIN PLAN output, SQL Plan Cache exports, expensive statement trace results, monitoring view query outputs, architecture documents, or descriptions provided by the user
+- `context7-supplementary` — grounded in SAP HANA Cloud SQL reference or SQLScript documentation from Context7 (supplementary; applies when SQL statement-level or SQLScript procedure-level guidance is in scope)
+- `inference` — derived reasoning not directly confirmed by official docs or user evidence; must always be labeled as such