Transpiles a single COBOL program (already analysed and rule-extracted) into idiomatic Java 21 + Spring Boot 3.x source code, using the target repository's style profile, the copybook-mapping records, and the jpa-mapping entities as the canonical type system. Emits one orchestrator service per PROGRAM-ID, one package-private paragraph method per PERFORMable paragraph, a sealed result type per EVALUATE TRUE block, and a `transpile-report.json` sidecar that pins every emitted Java line back to (source.sha256, originalLine) for audit. USE WHEN the user has `program-profile.json` (schemaVersion 1.0) AND `business-rules.json` (schemaVersion 1.0) AND at least one `copybook-mapping.json` for every COPY member used by the program AND wants runnable Java 21 source, not pseudocode. DO NOT USE for: copybook-only conversion (use `convert-copybook-to-java-record`); JCL → workflow conversion (use `map-mainframe-job-flow` + `plan-strangler-fig-migration`); ER/flow diagrams (use `diagram-cobol-with-mermaid`); whole-portfolio
Maps the persistent-data surface of one Enterprise COBOL program — its VSAM file definitions (`SELECT ... ASSIGN`, `FD`, key structure from the FILE-CONTROL paragraph and the associated record copybook) and its embedded DB2 access (`EXEC SQL DECLARE TABLE`, DCLGEN copybooks, `EXEC SQL SELECT/INSERT/UPDATE/DELETE/FETCH ... INTO :host-var`) onto idiomatic Spring Data JPA artefacts for Java 21 + Spring Boot 3.x: one `@Entity` class per VSAM file or DB2 table, one `JpaRepository<Entity, Key>` per entity, a composite `@IdClass` or `@EmbeddedId` when the key has more than one field, a `jpa-mapping.json` sidecar that records every host-variable → column → record-component binding (so `transpile-cobol-to-java21` can rewrite `EXEC SQL` blocks into repository or `EntityManager` calls without re-parsing the COBOL), and an optional Flyway-style baseline DDL derived from the DECLARE TABLE statements. USE this skill when `analyze-cobol-program` has surfaced `data.files[]` of type VSAM (KSDS / ESDS / RRDS) and/or `data.dbAc
Converts one Enterprise COBOL copybook (a `.cpy`, `.cbl`, or `.cob` file containing only DATA-DIVISION-style 01-level group items, no PROCEDURE DIVISION) into one or more idiomatic Java 21 `record` types plus a deterministic `copybook-mapping.json` artifact that documents every field-level mapping (COBOL name + PICTURE + USAGE → Java name + Java type + scale + nullability + EBCDIC byte offset). Handles fixed-format and free-format copybooks; resolves `OCCURS` to `List<T>`, `OCCURS DEPENDING ON` to a bounded list with a runtime size guard, `REDEFINES` to a Java 21 sealed interface with one record per variant, `COMP-3` / `PACKED-DECIMAL` to `BigDecimal` with explicit `scale`, `COMP` / `BINARY` to `int` / `long` / `BigInteger` by digit count, and `PIC X(n)` / `PIC A(n)` to `String` (trailing-space semantics recorded in the mapping). USE this skill when you have a copybook (typically surfaced by `analyze-cobol-program#/data/copybooks[]`) and need immutable Java DTOs that downstream skills (`map-vsam-db2-to-jpa`,
Renders deterministic Mermaid diagrams (flowchart, sequenceDiagram, classDiagram, erDiagram, stateDiagram-v2) from upstream JSON artifacts produced by `analyze-cobol-program` (`program-profile.json`), `extract-cobol-business-rules` (`business-rules.json`), and `map-mainframe-job-flow` (`job-flow.json`). USE when the user asks to "visualise", "draw", "diagram", "render a chart of", "show the call graph / job flow / paragraph flow / data model / state machine" of a COBOL program, copybook set, or JCL job, OR when a downstream skill (`plan-strangler-fig-migration`, `generate-modernization-tests`) needs an embeddable diagram for documentation. DO NOT USE for free-form architecture whiteboarding, for diagrams of Java-21 target code (use a dedicated Java diagrammer), for sequence traces that require runtime data, or when the upstream JSON artifact does not yet exist — run the upstream extractor first. This skill is read-only over its inputs, emits only `.mmd` / `.md` files, and must produce byte-identical output ac
Parses one or more z/OS JCL job streams (and any in-stream or cataloged PROCs you provide) and emits a deterministic, machine-readable "job-flow profile" plus a short human brief. The profile enumerates JOB cards, EXEC PGM= / EXEC PROC= steps, expanded PROC steps with symbolic parameter substitution, DD statements with DSN / DISP / organization, JOBLIB / STEPLIB / JCLLIB, COND and IF/THEN/ELSE/ENDIF control flow, RESTART / CHKPT, GDG references, instream SYSIN, plus cross-step and cross-job dataset dependencies derived from DISP=(NEW|OLD|SHR|MOD,…) read-after-write edges. USE this skill whenever you need to understand WHICH programs run in WHICH order, with WHICH datasets, before extracting business rules or planning a Strangler-Fig migration of a batch suite. DO NOT use it for: (a) a single COBOL program's internal call graph — use `analyze-cobol-program`; (b) repo-wide language/build inventory — use `scan-target-repo-patterns`; (c) rendering Mermaid diagrams directly — chain into `diagram-cobol-with-mermaid
Reads the `program-profile.json` emitted by `analyze-cobol-program` together with the original COBOL source (and any resolved copybooks) and derives a deterministic catalog of **business rules** — discrete, human-readable statements of WHAT the program decides, calculates, validates, or persists, with verbatim source citations for every rule. Each rule has a stable ID, a type (CALCULATION, VALIDATION, BRANCHING, LOOKUP, MAPPING, FLAG-MUTATION, IO-EFFECT, ERROR-HANDLING), a plain-language statement, the COBOL predicates and expressions it was lifted from, the data items it reads/writes, and a confidence score. USE this skill after `analyze-cobol-program` has succeeded, whenever you need a reviewable business specification before transpiling, writing characterisation tests, or drafting a target Java domain model. DO NOT use it: (a) to parse COBOL from scratch — run `analyze-cobol-program` first and pass its profile; (b) to translate rules into Java — chain into `transpile-cobol-to-java21`; (c) to render flowcha
Parses a single Enterprise COBOL source program (and its directly COPY-ed copybooks, if provided) and emits a deterministic, machine-readable "program profile" plus a short human brief. The profile enumerates divisions, sections, paragraphs, the PERFORM call graph, CALL'd sub-programs, COPY members, FD/SELECT file usage, EXEC SQL and EXEC CICS blocks, LINKAGE parameters, and complexity metrics (LOC, cyclomatic, paragraph fan-in / fan-out, nesting depth). USE this skill as the first per-program step of a COBOL-to-Java modernization pipeline, whenever you need a structural map of one program before extracting business rules, drawing diagrams, or transpiling. DO NOT use it for: (a) JCL job flow across multiple programs — use `map-mainframe-job-flow` instead; (b) deriving business rules in natural language — chain into `extract-cobol-business-rules`; (c) generating Mermaid diagrams directly — chain into `diagram-cobol-with-mermaid`; (d) repository-wide scans — use `scan-target-repo-patterns`. Inputs: one `*.cbl|*