Create Program

SC4SAP Create Program

Core ABAP program creation skill. Generates a Main Program wrapped with conditional Includes following the sc4sap template convention. Supports both OOP (two-class split: Data + Screen/ALV) and Procedural (PERFORM) paradigms. Full pipeline: SAP version preflight → Socratic interview → planner → writer spec → user confirm → executor/qa/reviewer.

<Response_Prefix>Every response triggered by this skill MUST begin with [Model: <main-model> · Dispatched: <sub-summary>] per ../../common/model-routing-rule.md § Response Prefix Convention.</Response_Prefix>

<Phase_Banner>Multi-phase skill. Before each Agent(...) dispatch, emit ▶ phase=<id> (<label>) · agent=<name> · model=<Opus|Sonnet|Haiku> per ../../common/model-routing-rule.md § Phase Banner Convention. Resolve the dispatch mode first per ../../common/model-dispatch-mode.md: auto (default) uses the model below/in the rule; user-defined asks the user Opus / Sonnet / Haiku (recommended one first) before each dispatch group. Resolve the cost mode too per ../../common/cost-mode.md (standard default; eco → pass BOTH model and effort on every Agent(...) call per its lever-A table (omitting effort silently runs the agent at its frontmatter effort, usually high), Skill("sc4sap:eco", "--attach") first and on every continuation turn, and this skill's eco recipe).</Phase_Banner>

<Team_Mode>Four teamMode integration points — Type A: Phase 1A (post-interview cross-module consistency) + Phase 2 (planner conflict resolution) — see team-mode.md. Type B: Phase 4 Wave 2/3 — user opt-in at Phase 3.5 (default off; executor's novel code gets live consultant review) — see team-mode-b.md. Type D: Phase 1A↔1B bridge — user-chosen at Phase 1A close (legacy sequential 1B vs Type D team synthesis); analyst + architect + consultant parallel synthesis replaces sequential 1B when selected — see team-mode-d.md. Base protocol: ../../common/team-consultation-protocol.md.</Team_Mode>

<Use_When>

• User says "create program", "new report", "ALV program", "CRUD program", "make me a batch program", etc.
• A new ABAP executable program (REPORT) needs to be created from scratch
• Program requires the Main+Include wrapping convention
• ALV display is needed (full CL_GUI_ALV_GRID or simple SALV popup) </Use_When>

<Do_Not_Use_When>

• Creating a single class/interface/table — use /sc4sap:create-object
• Modifying an existing program — use direct UpdateProgram / UpdateInclude MCP calls
• Creating a RAP business object / OData service — use /sc4sap:create-object (with service binding + behavior definition)
• User wants only scaffolding without coding — use /sc4sap:create-object with type=program </Do_Not_Use_When>

<Shared_Conventions> The following rules are shared across sc4sap skills and live in sc4sap/common/. Load and apply them during the relevant phases of this skill:

Paths are relative to this skill's directory (sc4sap/skills/create-program/).

ECC DDIC fallback gate. When the planner's object list includes a new Table, Data Element, or Domain AND SAP_VERSION = ECC, Phase 4 (Executor) must not call CreateTable / CreateDataElement / CreateDomain. Instead, follow ../../common/ecc-ddic-fallback.md: generate a helper report in $TMP using the matching template under skills/create-object/ecc/, activate the helper, then emit the mandatory user message (SE38 run → uncheck dry-run → SE11 activate + assign transport). Do not treat the DDIC object as created until the user confirms activation. Remaining objects (classes, includes, screens, …) proceed on the normal flow; the plan should sequence the DDIC helpers first so the user can create them before code that depends on them is activated. </Shared_Conventions>

<Preflight_SAP_Version_Check> MUST run BEFORE the Socratic interview starts. The entire development approach (tables, BAPIs, CDS availability, ABAP syntax, RAP eligibility) depends on the SAP platform and release.

Steps:

1. Read .sc4sap/config.json for sapVersion, abapRelease, and activeModules
   • Also read .sc4sap/sap.env → SAP_ACTIVE_MODULES as fallback
   • Load common/active-modules.md and precompute the cross-module concern list for the program's primary module. Every downstream phase (planner, writer, executor) receives this list and must factor in integration fields (e.g., MM primary + PS active → add PS_POSID).
2. If missing or stale, ask the user to confirm:
   • ECC (ECC 6.0) — classical DDIC, LFA1/KNA1/BKPF/BSEG/MKPF/MSEG world, SAPGUI only
   • S/4HANA On-Premise — ACDOCA, MATDOC, Business Partner (BUT000), CDS/AMDP preferred, Fiori possible, ADT-first
   • S/4HANA Cloud (Public) — no classical Dynpro, no SE80 custom dev, only Developer Extensibility / Key User Extensibility (RAP managed, Custom Fields/Logic, Custom Business Objects)
   • S/4HANA Cloud (Private) — similar to On-Premise but with extensibility-first mindset
3. Confirm abapRelease (e.g. 750, 756, 758) — drives allowed syntax

Branching consequences:

• ECC: no RAP, no ACDOCA, no Business Partner; inline decl only if 740+; CDS/AMDP typically unavailable (<750)
• S/4HANA On-Prem: prefer CDS + AMDP, RAP where applicable, Business Partner APIs, ACDOCA for finance
• S/4HANA Cloud Public: REJECT classical Dynpro / custom screen + GUI Status requests. The standard Full-ALV path (CL_GUI_ALV_GRID + Docking Container) is not executable on Cloud Public — must redirect to RAP + Fiori Elements, if_oo_adt_classrun, or SALV-only output. Fail-fast with an explanation. Full prohibited-statement list and Cloud-native API replacements: see ../../common/cloud-abap-constraints.md.
• S/4HANA Cloud Private: classical Dynpro technically possible but discouraged; warn user and confirm intent before proceeding.

Outputs:

• .sc4sap/program/{PROG}/platform.md — resolved platform, release, and constraints
• Interview dimensions pre-filtered by platform (e.g., ALV-Full hidden on Cloud Public) </Preflight_SAP_Version_Check>

<Inventory_Lookups> Runs immediately after package + module are resolved during the interview (Phase 1 dimension #6) and feeds every downstream phase. Two sequential inventory passes: CBO Inventory (reusable Z*/Y* objects in the target package — delegated to sap-stocker on cache miss) then Customization Inventory (existing BAdI impls / CMOD projects / form-based exits / appends per module).

Full procedure (when-to-stock, three-option prompt, dispatch template, persistence paths, reuse-gating rules) lives in inventory-lookups.md. Read and follow literally. Output files consumed by planner / writer / executor:

• .sc4sap/program/{PROG}/cbo-context.md
• .sc4sap/program/{PROG}/customization-context.md </Inventory_Lookups>

<Interview_Gating> MANDATORY — never skip, never shortcut, never merge. Phase 1 runs as two sequential sub-phases (1A then 1B) on every sc4sap:create-program invocation.

Full procedure — two-stage rule, lead agents, dimension lists, skip rules, gates, output files, and enforcement contracts — lives in interview-gating.md. Read that file and follow it literally before asking the first question.

One-line summary:

Phase 1A sap-{module}-consultant interviews business context (purpose / reason / company rules / reference assets / standard-SAP alternatives) → file module-interview.md, gate ≤ 5% → Phase 1B sap-analyst + sap-architect interview technical dimensions (purpose-type / paradigm / display / screen / data / package / test) → file interview.md, gate ≤ 5% → proceed to <Spec_Approval_Gate>. Phase 1B never starts before 1A closes; Phase 2 planner refuses to run if either file is missing. </Interview_Gating>

<Spec_Approval_Gate> MANDATORY — never skip, never shortcut. After <Interview_Gating> closes (ambiguity ≤ 5%) and Phase 2 (Planning) produces plan.md, the skill MUST run a spec-approval gate before any Create* / Update* MCP call.

Full procedure — required steps, enforcement contract, rationale, spec template, and the verbatim user-facing approval prompt — lives in spec-approval-gate.md. Read that file and follow it literally.

One-line summary (the full text lives in the companion file):

Invoke sap-writer → produce spec.md → display to user → wait for an explicit approval keyword (승인 / approve / ok / proceed / go ahead / confirmed). "yes" / "빨리" / "해봐" / silence are NOT approval — loop with revisions. Phase 4 Executor refuses to run if spec.md is missing, unapproved, or modified after approval. </Spec_Approval_Gate>

<Session_Trust_Bootstrap> MANDATORY — runs at the very start of Phase 1A, BEFORE the module consultant asks the first question. Invoke /sc4sap:trust-session with parent_skill=sc4sap:create-program to pre-grant MCP tool + file-op permissions for the entire session. This ensures interview-time MCP calls (consultant SPRO lookups, SearchObject, GetWhereUsed) and downstream Phase 4–8 activity both run without permission prompts.

• If .sc4sap/session-trust.log already has a line within the last 24h, skip silently.
• Exception: GetTableContents and GetSqlQuery are NEVER auto-approved — they require explicit per-call user consent. See ../trust-session/SKILL.md Layer 1. </Session_Trust_Bootstrap>

<Execution_Mode_Gate> MANDATORY — runs between <Spec_Approval_Gate> and Phase 4. After spec approval, the skill prompts the user to pick an execution cadence: auto / manual / hybrid. Persists the choice to .sc4sap/program/{PROG}/state.json under execution_mode.

trust-session is NOT re-invoked here — it already ran at the start of Phase 1A.

Full procedure — verbatim mode-prompt text, per-mode semantics, state.json schema (also drives C-2 resume support), and manual-mode phase-transition prompt — lives in execution-mode.md. Read that file and follow it literally before dispatching Phase 4. </Execution_Mode_Gate>

<Agent_Pipeline> The full phase-by-phase pipeline (Phase 0 – Phase 8) lives in agent-pipeline.md in this skill folder.

Read that file before dispatching any agent. It is the authoritative source for:

• Phase 0 — SAP Version Preflight
• Phase 1A — Module Interview (sap-{module}-consultant, business context)
• Phase 1B — Program Interview (sap-analyst + sap-architect, technical dimensions)
• Phase 2 — Planning (sap-planner + consultants, CBO reuse gate, SPRO lookup)
• Phase 3 — Spec Writing (sap-writer)
• Phase 4 — Implementation (sap-executor)
• Phase 5 — QA (sap-qa-tester, OOP mode)
• Phase 6 — Review (sap-code-reviewer, mandatory, see phase6-review.md)
• Phase 7 — Debug escalation (sap-debugger)
• Phase 8 — Completion Report (gated on Phase 6 PASS)

Do not inline or paraphrase phase logic here — update agent-pipeline.md instead so the pipeline stays single-sourced. </Agent_Pipeline>

<MCP_Tools_Used>

• SearchObject — existence check
• ListTransports / CreateTransport — transport management
• GetPackage — package validation
• CreateProgram + UpdateProgram — main program
• CreateInclude + UpdateInclude — all includes (TOP/SEL/CLASS/ALV/PBO/PAI/EVENT/FORM/TEST)
• CreateScreen + UpdateScreen — custom screens (ALV full mode)
• CreateGuiStatus + UpdateGuiStatus — PF-Status for custom screens
• CreateTextElement + UpdateTextElement — text-xxx resources
• GetAbapSemanticAnalysis — pre-activation syntax check
• GetInactiveObjects — post-activation verification
• RunUnitTest / GetUnitTestResult — QA (OOP mode) </MCP_Tools_Used>

<State_Files>

• .sc4sap/program/{PROG}/platform.md — Phase 0 preflight output
• .sc4sap/program/{PROG}/module-interview.md — Phase 1A business interview (consultant-led: purpose / reason / company-specific rules / reference assets / standard-SAP alternatives)
• .sc4sap/program/{PROG}/interview.md — Phase 1B technical interview (analyst+architect-led: 7 dimensions + 2a code template Q&A log)
• .sc4sap/program/{PROG}/cbo-context.md — CBO reuse candidates (written by <Inventory_Lookups> / inventory-lookups.md)
• .sc4sap/program/{PROG}/customization-context.md — Z*/Y* BAdI impl / CMOD / form-exit / append reuse candidates (written by <Inventory_Lookups> / inventory-lookups.md)
• .sc4sap/program/{PROG}/ddic-brief.md — Haiku sap-checker scout facts for objects named in Phase 1A (read before any Get* by 1B / consultants / planner)
• .sc4sap/program/{PROG}/plan.md — planner output
• .sc4sap/program/{PROG}/spec.md — writer output (requires user confirm)
• .sc4sap/program/{PROG}/state.json — execution_mode + per-phase status/timing (schema in execution-mode.md, drives resume support)
• .sc4sap/program/{PROG}/verify-phase4.md — Haiku verify results for text pools, screens, GUI statuses, inactive count (see phase4-verify.md)
• .sc4sap/program/{PROG}/review-bucket-{B1|B2|B3|B4}.md — Phase 6 per-bucket reviews, buckets strategy (merged into review.md, see phase6-buckets.md)
• .sc4sap/program/{PROG}/review-candidates.md — Phase 6 Haiku detector output, detect-judge strategy (see phase6-detect-judge.md)
• .sc4sap/program/{PROG}/review.md — Phase 6 consolidated review
• .sc4sap/program/{PROG}/report.md — final completion report
• .sc4sap/program/{PROG}/{spec,report}.html — optional single-file HTML copies, offered after Phase 8
• .claude/settings.local.json — permissions allowlist (written by /sc4sap:trust-session during Phase 3.5)
• .sc4sap/session-trust.log — audit trail of trust-session invocations </State_Files>

Task: $ARGUMENTS