Compile SOPs from your repo — CI Compiler Desk

The CI compiler desk is for teams whose SOP documents live in a version-controlled repository. On every push to a watched folder, the cromus-compile Action compiles changed documents into SKILL.md files and opens a pull request. Pair it with the Cromus Gate step and the generated skills receive Specialist findings on the same PR before anything merges.

The compiler creates; the Specialist reviews; nothing machine-generated merges without a verdict.

For teams that prefer a no-repo path — paste an SOP, compile, score, and simulate in one session — the in-app compiler in Skill Studio is the primary surface and covers everything described here without a CI setup.

How it works

Push to watched folder (default: sops/)
        ↓
cromus-compile Action calls POST /api/ci/compile
        ↓
Compiler turns each changed document into a SKILL.md file
        ↓
Action writes SKILL.md files to the output folder (default: skills/)
        ↓
Action opens (or updates) a pull request listing each generated skill
        ↓
(Recommended) Cromus Gate step scores the generated skills on the same PR
        ↓
Human reviews the PR — compiler drafts, Specialist verdict, nothing auto-merges

Setting up the action

1. Generate a CI key

Cromus → Account → CI and Developer → Generate.

2. Store as a secret

Add CROMUS_CI_KEY to your repository's Actions secrets.

3. Add the workflow

Create .github/workflows/cromus-compile.yml:

name: Compile SOPs

on:
  push:
    paths:
      - 'sops/**'

permissions:
  contents: write
  pull-requests: write

jobs:
  compile:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Compile SOPs to skills
        uses: cromus/compile-action@v1
        with:
          cromus-api-key: ${{ secrets.CROMUS_CI_KEY }}
          watch-folder: sops/
          output-folder: skills/

That is all that is required. The action opens or updates a pull request containing the compiled SKILL.md files and a summary of each skill's compilation metadata.

Recommended: compile with built-in Specialist review

Add also-gate: 'true' to the compile step and the action scores each generated skill immediately after writing it. The Specialist findings are appended to the pull request body and written as step annotations — no second step needed. The compiler drafts your skills; the Specialist reviews them, deterministically. Generation is creative; judgment never is.

name: Compile SOPs with Specialist review

on:
  push:
    paths:
      - 'sops/**'

permissions:
  contents: write
  pull-requests: write

jobs:
  compile:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Compile SOPs to skills (with Specialist review)
        uses: cromus/compile-action@v1
        with:
          cromus-api-key: ${{ secrets.CROMUS_CI_KEY }}
          watch-folder: sops/
          output-folder: skills/
          also-gate: 'true'

The also-gate flag scores generated skills using the same /api/ci/score endpoint as the standalone Gate action. Gate scoring is unlimited on every plan and never counts against compile allowances.

If you prefer the Gate to run as a separate step on a pull-request event (for example, to also score hand-edited skills in the same PR), set up a second workflow that triggers on pull_request and points glob at your skills folder.

The pull request

The action opens one pull request per unique set of changed source files. The PR branch name is derived from a stable hash of those file paths, so the same set of documents always maps to the same branch. If that branch already has an open PR the action updates it rather than opening a duplicate. A subsequent push that changes a different set of documents produces a new branch and a separate PR. The PR body lists:

• Each source document that was compiled
• The corresponding SKILL.md file path
• A compilation metadata summary (detected steps, tool calls, budget candidates)
• A note that the files are machine-generated drafts pending review

If the gate step is also running, its Specialist findings appear as workflow step annotations and as a step summary on the same PR.

Failure behavior

When a document cannot be compiled — unsupported format, parse error, or a fair-use limit reached — the action:

• Writes a named annotation for that document describing the failure in plain language
• Continues compiling any remaining documents in the same run
• Includes the failed document in the PR body with its failure reason

No document failure is silent and no failure blocks sibling documents from completing.

Fair-use note

The compile endpoint consumes model tokens and carries per-account daily and monthly allowances by plan. Gate runs (scoring) remain unlimited on every plan, permanently — compile limits are never gate limits.

When an account reaches its compile allowance, the action receives a plain-language message with a link to the fair-use policy. Gate steps on the same workflow continue running normally.

Supported document formats

The CI compiler accepts the same formats as the in-app compiler: Markdown, plain text, DOCX, and PDF.

Folder convention

Files in the watch folder are matched by extension. Nested subfolders are included. Each source document produces one SKILL.md file in a subdirectory of the output folder named after the source file stem (for example, sops/content-review.md → skills/content-review/SKILL.md).

Plan availability

The CI compiler desk is available on Builder and above. All plans that include CI key access can use /api/ci/compile.

Further reading

• Cromus Gate — CI/CD integration
• Plan limits and features