Skip to content

CI coverage and ownership baseline

This is the pre-migration baseline for spec 367 and ticket 371, observed October 22, 2026. Source baseline: 9661fd7. This document records observations separately from proposed routing. Forge maintains its native workflows; generated consumers own their emitted YAML after bootstrap. No repository settings, deployments, reference repositories, or pipelines were changed to collect evidence.

Evidence and protection

Read-only GitHub REST requests inspected branches/main/protection, rulesets, environments, each environment’s deployment-branch-policies, and Actions runs/jobs. No repository rulesets were returned. Main enforces protections for administrators; strict up-to-date checks, signatures, force pushes, branch deletion, linear history, and conversation resolution are disabled. There are 27 required GitHub Actions contexts (application ID 15368), listed in the migration table below. The native Rust job is a build prerequisite but is not itself a required context. Website, CodeQL, and workflow-scanning contexts are not in this required-check list.

EnvironmentObserved protectionWorkflow owner
github-pagesCustom branch policy: main; no reviewer ruleWebsite deployment
npm-releaseFour tag policies: content-model-v*, create-forge-v*, browser-oxfmt-v*, markdownlint-frontmatter-v*; reviewer rahul0705, self-review allowedManual/tag package publication
npm-release-autoCustom branch policy: main; no reviewer ruleReviewed automatic patch publication

All three environments allow administrator bypass. Environment secret values were not requested. GitLab CI Lint, mirror runner execution, GitLab branch protection, and reference-site protections were not inspected; native YAML and local contract tests cannot establish those live facts. Consumer protections are repository settings and cannot be inferred from generated YAML.

Responsibility and trigger matrix

The detailed job/command/artifact inventory follows later in this document. All root npm checks use the root lock; website and generated consumers install their own committed lock. Permissions start empty unless noted, and jobs request only their documented scopes.

SourceOwner and purposeCurrent triggerConcurrency and effects
.github/workflows/project.ymlForge package/tool correctness and inspected candidate packsEvery PR to/main pushWorkflow/ref; cancels PRs only; read contents
.github/workflows/generator.ymlPacked CLI, isolated generated consumer, tool regressionsEvery PR to/main pushWorkflow/ref; cancels previous; read contents, generated security writes security events
.github/workflows/website.ymlIsolated website quality, browser/accessibility, budget, deployment and smokePR/main push affecting website/**, docs/**, its YAML or setup actionWorkflow/ref; cancels PRs only; deploy writes Pages/OIDC
.github/workflows/browser-oxfmt.ymlNative reproducibility, packed browsers and CMS serializationPR affecting native package, template, root lock, formatter/linter/spelling config or setup; manualBrowser/ref; cancel previous; read contents
.github/workflows/documentation.ymlExternal documentation link healthTuesday 09:31 UTC; manualWorkflow/ref; cancel previous; read contents
.github/workflows/automation.ymlForge workflow syntax/security.github/** PR/main push; Monday 05:43 UTCWorkflow/ref; cancel previous; security-events write for scanner
.github/workflows/security.ymlCodeQL Actions/JS/Rust and PR dependency reviewEvery PR/main push; Monday 05:17 UTCWorkflow/ref; cancel previous; actions/contents read, security-events write
.github/workflows/gitlab-sync.ymlMirror main/tags, no production publicationMain/tag push; manual; configured destination requiredGlobal serialized group; no cancellation; contents read plus mirror credential
.github/workflows/package-release.ymlSelect approved release, validate exact commit, publish inspected artifactPackage tags; main package manifest changes; manualRef group, no cancellation; prepare reads contents/PRs; publish contents/OIDC write
.github/workflows/peer-upgrades.ymlReviewable peer compatibility update and supported CMS synchronizationFriday 06:07 UTC; manualGlobal serialized group; read contents; synchronization actions write; App creates PR
.github/workflows/oxfmt-upgrades.ymlReviewable coordinated native engine updateFriday 06:23 UTC; manualGlobal serialized group; read contents; App creates PR
.github/workflows/template-sync.ymlVerify publication then update registry-pinned templatecontent-model-published dispatch; manualGlobal serialized group; actions/contents read; App creates PR and enables checked auto-merge
.gitlab-ci.yml and .gitlab/ci/*.ymlSupplemental native project/generator/website validationMerge request; default-branch push; suppress duplicate branch/MR pipelinesJobs interruptible; includes select generator/website changes; production deploy/smoke disabled

There is no broad scheduled package/generator/website validation today. Security, automation, external links and dependency-update schedules cover different responsibilities. Default proposal: one weekly broad validation of all lanes, with manual dispatch for diagnosis; retain post-deployment smoke. Daily fresh installs remain outside this spec and depend on the separate lockfile experiment.

Consumption graph and proposed routing

Input → consumerEdge typeConsequence
packages/* → root workspacesLocal source/buildChanged package tests, types, build and pack; actual dependents follow workspace imports
templates/default → create-forge distribution → generated projectCopied outputGenerator build materializes template; packed CLI generation and consumer local commands protect shipped files
packages/create-forge/src/ci → consumer YAMLGenerated outputProvider contracts, syntax/security, deployments and command/artifact behavior need generated validation
Template @rm-industries/content-model@1.1.7 → generated sitePublished npm, lock-pinnedLocal content-model source does not replace this dependency or imply consumer release
Local content-model → test:frontmatter:cmsExplicit candidate buildProtect model-derived field ordering and native CMS saves; not a registry compatibility claim
Local browser-oxfmt → isolated packed browser consumers and serialization probeCandidate artifactTest WASM/worker package and native serialization integration separately from template adoption
docs/**/*.md → website Astro glob loaderLocal contentDocumentation edits can alter website pages, links and budgets; preserve site validation
Website source/lock → websiteIndependent projectWebsite has no local package dependency; package membership alone must not select website
Root config, setup action, scripts, lock, CI → their usersShared toolingSelect all affected jobs; uncertain ownership falls back to broad validation
Native Cargo/WASM inputs → browser formatter build → tested tarballLocal build outputInclude Rust formatting/linting, reproducible engine, package identity, supported runtimes and browser checks

Candidate overlays are intentional test setup, not release dependencies. Preserve the isolated website boundary (ADR 0007), independent versions (ADR 0006), and frontmatter package boundary (ADR 0008). The root lock changing does not modify website’s lock, but shared root checks still use that lock. Website checks consume docs at build time; a docs-only policy that skips every website check is unsound.

Cost observations

Times below are observed UTC job durations, including setup but excluding time waiting for prerequisites. Elapsed workflow time includes orchestration/queue time. Samples are successful runs, not statistical medians, billed minutes, or a controlled before/after benchmark. Different runs can have different changes.

RunEventJobsElapsedExpensive observations
Project 39788493256PR146m 50sRust 151s; build 207s; four compatibility lanes 24–32s each
Generator 39788493387PR144m 22sFive consumer lanes 38–60s; browser 127s; Lighthouse 157s; scenarios 100s
Website 39787960075Main push145m 26sBrowser/accessibility 142s; Lighthouse 147s; build 29s; deployed smoke 56s
Native 39788493244PR1 workflow5m 58sNative reproducibility, packed browsers, CMS; per-step timing not captured
Security 39788493229PR1 workflow6m 39sCodeQL matrix and dependency review; job timing not captured

The first two workflows alone submit 28 jobs for every PR before security, native and website selection. A website main push adds deployment and smoke; a PR skips those two jobs. A 40-run recent sample included many cancelled main pushes; do not treat cancellation time as the cost of a successful run. The older project run 39713028851 spans about 7.5 hours because it was updated later; created-to-updated elapsed is unreliable as runner cost. Re-measure with job start/end times and identical change classes.

Overlap to remove carefully: project packages CLI while generator separately packages CLI; root static checks and independent site static checks overlap file surfaces; generator scenarios and five consumer lanes repeat installs/builds intentionally across runtime/OS; root native quality and native reproducibility repeat Rust work for different contracts. Browser accessibility tests already use axe; Lighthouse’s accessibility score overlaps automated accessibility but also checks performance/SEO/best-practice budgets. Build validation checks files/metadata without browser interaction; smoke catches deployed base paths, assets and mobile layout after deployment, which local build/browser success cannot prove.

Existing optimization is retained: one canonical generated source and production build feeds downstream consumer quality/browser/Lighthouse/build validation, with per-runtime builds reserved for compatibility. The CMS native-save probes use focused Chromium and real serialization rather than a complete repeated multi-browser CMS editing suite. They still verify save ordering/convergence; formatter serialization probes additionally protect callback failures and unchanged input. No CMS protection is removed here.

Delivered-test disposition

Decisions below guide the consumer slice; no tests are removed by this inventory. Paths are relative to templates/default. Mixed files require splitting assertions, not deleting their durable protection.

Existing filePurpose and proposed dispositionRetained protection
src/config/site.test.tsDurable, retainCanonical URL validation, controls/links, browser-safe config and CMS branding
src/config/deployment.test.tsDurable, retainRoot and project base paths
src/lib/paths.test.tsDurable, retainBase-aware paths without double prefixes
src/lib/navigation.test.tsDurable, retainSegment boundaries, root and external URL handling
src/lib/articles.test.tsStarter regression, move to ForgeDraft filtering, order and pagination while article starter exists
src/themes/site-theme.test.tsStarter regression, move to ForgeCatppuccin flavors/default selection
src/content.config.test.tsDurable, retainEvery declared model reaches Astro collections
src/config/content-models/registry.test.tsMixed: move fixed article/tags assertion; retain duplicate model rejection at package seamNo duplicate collection names; starter registry stays covered in Forge
src/integrations/sveltia/config.test.tsMixed: retain credential exclusion/serialization, move fixed article/tags shapeSafe configuration and editing/build model agreement
src/integrations/sveltia/preview-collections.test.tsDurable, retainRich-content collections register previews
src/integrations/sveltia/previews.test.tsStarter regression, move to ForgeExample article preview rendering
scripts/validate-build.test.tsDurable, retainMissing artifacts and unresolved generator tokens rejected
scripts/run-lighthouse.test.tsDurable, retainAudited URLs honor deployment base
scripts/documentation-examples.test.tsExample-only assertion, move to Forge and document patternStarter article avoids duplicate title heading
tests/routes.spec.tsMixed: move fixed article/routes/feed examples; retain CMS noindex, internal links and generic metadata contractConfigured output, safe admin indexing, broken links
tests/navigation.spec.tsStarter regression, move fixed links/article traversal to ForgeMobile navigation behavior remains covered by accessibility checks
tests/theme.spec.tsMixed: move named palette assertions; retain local fonts/visible keyboard focusAccessibility and local assets
tests/accessibility.spec.tsDurable, retain and derive routesSerious/critical axe findings, landmarks/headings, skip link, mobile overflow, reduced motion
tests/smoke/deployment.spec.tsDurable, retain and derive routesLive deployment URL/assets, navigation/mobile wiring

tests/preview.ts is support code, not an assertion suite. Preserve it wherever retained tests need it. Routes/names/colors are replaceable examples; security, accessibility, content preservation and generic CMS editing-to-build checks remain obligations. Document optional example patterns rather than shipping assertions about a consumer’s choice of content. Native CMS probes and packed generator end-to-end tests stay Forge-owned even when consumer examples move.

Required-check migration and rollback proposal

This is a proposal, not an applied protection change. Three always-created summaries keep the required surface small while reporting explicit success for unaffected work. The routing selector must be a prerequisite whose failure/cancellation cannot be interpreted as an unaffected lane.

Existing required contexts (27 total)Proposed stable required context
Tool Format; Tool Lint code; Tool Lint Markdown; Tool Spellcheck; Tool Documentation links and commands; Tool Type-check; Tool Test; Tool Build; Tool Pack; Tool Compatibility (minimum Node 22); Tool Compatibility (latest Node 22); Tool Compatibility (latest Node 24); Tool Compatibility (latest Node 26)Forge project
Package generator candidate; Consumer compatibility (minimum Node 22 on Ubuntu); Consumer compatibility (latest Node 22 on Ubuntu); Consumer compatibility (latest Node 24 on Ubuntu); Consumer compatibility (latest Node 26 on Ubuntu); Consumer compatibility (latest Node 26 on macOS); Consumer source quality; Consumer build validation; Consumer browser tests; Consumer Lighthouse budgets; Generated workflow security; Generated workflow syntax; Generator behavior scenarios; Consumer quality tool regressionsForge generator
No existing required website contextForge website

Native verification must feed the project summary when selected. Security and automation keep their responsibilities; their routing must not disappear accidentally behind package selection. Final names may be coordinated by the workflow slice, but the operator must record the exact resulting map.

Deploy code first with both old checks and summaries observable. Collect real PR evidence for success, unaffected lanes and failures before requesting authorization to change required contexts. Change settings only after all new names exist; keep the previous context list for rollback. Do not remove old job contexts while they remain required: skipped entire workflows can leave branch protection waiting forever. If migration fails, restore the original workflow graph and 27 contexts together. Disable selective routing or dispatch broad validation while diagnosing; never turn a missing result into success. Preserve exact release-commit validation, inspected tarball handoff, immutable tags, provenance and environment approval. No mirror production publishing or PR deployment may be introduced.

Representative change and failure matrix

ScenarioRequired behavior to prove
Documentation-onlyRoot documentation/static checks plus website content/build impact; unrelated package builds unaffected
Website-onlyWebsite static/build/browser/budgets; no unrelated local package checks
Each packageIts source/types/tests/build/pack and actual local consumers; registry-pinned template unchanged unless explicit candidate seam
Template or CI builderPacked CLI generates isolated project; local scripts and both providers remain valid
Content/layout/CMS/dependencies/build configRelevant browser/accessibility/Lighthouse and CMS integration selected
Root lock/shared config/setup/workflowEvery actual tooling consumer selected; broad fallback for uncertain scope
Cargo/Rust/WASMNative reproducibility/quality, packed browser identity, runtime/browser compatibility
Addition/deletion/renameClassify both old and new paths; a deleted known input still selects its consumers
Mixed changesUnion of affected responsibilities
Missing diff, unsupported event or unknown pathBroad validation; selector execution failure makes summary fail
Unaffected laneSummary is present and explicitly succeeds without expensive jobs
Failed prerequisite, cancelled work, mixed successes/failuresRequired summary fails; no skipped dependency can hide failure
Schedule/manualBroad validation without PR production deployment
Main deploymentBuild verified artifact once, primary provider deploys, smoke verifies returned deployment URL

Provider-native negative execution remains required evidence for downstream work; static YAML checks prove structure only. Record before/after job counts and timings for comparable representative changes, separately from coverage decisions and authorized branch-protection migration.

Workflow job inventory at baseline

Job IDs below are the stable dependency pointers; matrix names expand at execution. Commands are listed by their public npm entry points or step purpose where shell orchestration is involved. The linked source retains complete shell bodies, guards and action pins. Artifact names/paths identify the existing handoffs; they are not interchangeable with a fresh build from another commit.

Repository Automation Validation

Source: automation.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
security / Workflow securityScan workflows—{“contents”:“read”,“security-events”:“write”}
syntax / Workflow syntaxValidate workflows—{“contents”:“read”}

Browser Oxfmt Package

Source: browser-oxfmt.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
package / Rebuild native assets and verify packed browsersnpm run build:native —workspace @rm-industries/browser-oxfmt — —force; npm run build:native —workspace @rm-industries/browser-oxfmt — —force; npm run quality:native —workspace @rm-industries/browser-oxfmt; npm run typecheck —workspace @rm-industries/browser-oxfmt; npm test —workspace @rm-industries/browser-oxfmt; npm run build —workspace @rm-industries/browser-oxfmt; npm ci —prefix templates/default —ignore-scripts; npm run test:browser —workspace @rm-industries/browser-oxfmt; npm run build —workspace @rm-industries/content-model—{“contents”:“read”}

Source: documentation.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
external-links / External linksnpm run docs:links:external—{“contents”:“read”}

Generator CI Validation

Historical source: generator.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
package / Package generator candidatenpm ci; npm run build —workspace @rm-industries/create-forge; npm pack —ignore-scripts —workspace @rm-industries/create-forge —pack-destination “$RUNNER_TEMP/forge-packages”—generator-package{“contents”:“read”}
consumer-compatibility / Consumer compatibility (${{ matrix.runtime }})Bootstrap once on this runtime; npm ci; Verify locked content-model; npm run typecheck; npm run test:coverage; else npm test; fi; npm run buildpackagegenerator-package; consumer-source; consumer-build; consumer-coverage{“contents”:“read”}
quality / Consumer source qualityRestore the canonical consumer; npm ci; npm run format && npm run lint:code — —format github && npm run lint:css && npm run lint:markdown && npm run spellcheck && npm run audit:unusedconsumer-compatibilityconsumer-source{“contents”:“read”}
validate-build / Consumer build validationRestore the canonical consumer; npm ci; npm run validate:buildconsumer-compatibilityconsumer-source; consumer-build{“contents”:“read”}
browser / Consumer browser testsRestore the canonical consumer; npm ci; Install supported browsers; npm run test:e2econsumer-compatibilityconsumer-source; consumer-build; consumer-browser-results{“contents”:“read”}
lighthouse / Consumer Lighthouse budgetsRestore the canonical consumer; npm ci; Install Chromium; npm run lighthouse:ciconsumer-compatibilityconsumer-source; consumer-build; consumer-lighthouse{“contents”:“read”}
security / Generated workflow securityRestore the canonical consumer; Scan generated workflowsconsumer-compatibilityconsumer-source{“contents”:“read”,“security-events”:“write”}
syntax / Generated workflow syntaxRestore the canonical consumer; Validate generated workflowsconsumer-compatibilityconsumer-source{“contents”:“read”}
scenarios / Generator behavior scenariosnpm ci; Exercise distinct bootstrap behaviorspackagegenerator-package{“contents”:“read”}
static-tool-regressions / Consumer quality tool regressionsnpm run verify:template:static—{“contents”:“read”}

Sync GitLab

Source: gitlab-sync.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
sync / syncPush main and tags—{“contents”:“read”}

Browser Oxfmt Engine Updates

Source: oxfmt-upgrades.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
prepare / preparePrepare coordinated engine update; npm ci; npm run quality; npm ci —prefix templates/default —ignore-scripts; npm run test:browser —workspace @rm-industries/browser-oxfmt; Verify GitHub App configuration; Create GitHub App token; Resolve GitHub App identity; Push engine upgrade branch; Open engine upgrade pull request—{“contents”:“read”}

Package Release

Source: package-release.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
prepare / Prepare package releaseIdentify configured automation App; Select reviewed automatic patch; Verify release npm version; npm run —silent release:prepare — ”${arguments[@]}” —output .release/plan.json; npm run quality; npm pack —workspace “$WORKSPACE” —ignore-scripts —json —pack-destination .release > .release/pack.json; npm run —silent release:prepare — ”${arguments[@]}”—${{ steps.plan.outputs.artifact-name }}{“contents”:“read”,“pull-requests”:“read”}
publish / Publish packageEnsure immutable package tag; npm publish “$tarball” —access public —tag “$NPM_TAG” —provenance; Verify registry publication; Create GitHub release; Dispatch published content modelprepare${{ needs.prepare.outputs.artifact-name }}; published-${{ needs.prepare.outputs.package-slug }}-${{ needs.prepare.outputs.version }}{“contents”:“write”,“id-token”:“write”}

Peer Compatibility Updates

Source: peer-upgrades.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
prepare / Prepare compatibility updateVerify lockfile writer version; npm run —silent peer:prepare — ”${arguments[@]}”); then; Regenerate workspace lockfile; npm ci; Format compatibility manifests and notes; npm run quality; then; Verify GitHub App configuration; Create GitHub App token; Resolve GitHub App identity; Push compatibility branch; Open or update compatibility pull request; Report compatible current range—{“contents”:“read”}
synchronize-compatible / Synchronize an already supported Sveltia releaseTrigger published template synchronizationprepare{“actions”:“write”,“contents”:“read”}

Project Continuous Integration

Source: project.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
format / Tool Formatnpm run format—{“contents”:“read”}
lint-code / Tool Lint codenpm run lint:code — —format github—{“contents”:“read”}
lint-markdown / Tool Lint Markdownnpm run lint:markdown—{“contents”:“read”}
spellcheck / Tool Spellchecknpm run spellcheck—{“contents”:“read”}
documentation / Tool Documentation links and commandsnpm run docs:validate—{“contents”:“read”}
typecheck / Tool Type-checknpm run typecheck:root—{“contents”:“read”}
test / Tool Testnpm run test:root—{“contents”:“read”}
native / Tool Rust qualitynpm run quality:native —workspace @rm-industries/browser-oxfmt—{“contents”:“read”}
build / Tool Buildnpm run build; npm pack —ignore-scripts —workspaces —pack-destination “$RUNNER_TEMP/forge-packages”format, lint-code, lint-markdown, spellcheck, documentation, typecheck, test, nativeproject-packages{“contents”:“read”}
pack / Tool PackInspect published package contentsbuildproject-packages{“contents”:“read”}
compatibility / Tool Compatibility (${{ matrix.runtime }})Restore generated engine from the tested package; npm run typecheck:workspaces && npm run test:workspaces; Exercise candidate content-model exportsbuildproject-packages{“contents”:“read”}

Security Analysis

Source: security.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
code-analysis / Analyze (${{ matrix.language }})npm run build:native —workspace @rm-industries/browser-oxfmt; Initialize CodeQL; Perform CodeQL analysis—{“actions”:“read”,“contents”:“read”,“security-events”:“write”}
dependency-review / Review dependenciesReview dependency changes—{“contents”:“read”}

Published Template Synchronization

Source: template-sync.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
synchronize / Synchronize published content modelResolve verified publication; Read registry metadata; npm run —silent template:sync — ”${arguments[@]}”; npm run template:sync:lockfile; npm ci; npm ci —prefix templates/default; Install generated-project browsers; npm run quality; npm run verify:template; npm run test:generator:e2e; Verify GitHub App configuration; Create GitHub App token; Resolve GitHub App identity; Push synchronization branch; npm package: ${npm_url}” ; Report current template; Enable checked synchronization auto-merge—{“actions”:“read”,“contents”:“read”}

Forge Website Continuous Integration

Source: website.yml.

Job ID / checkCommands or action purposeNeedsArtifactsPermissions
format / Formatnpm run format—{“contents”:“read”}
spellcheck / Spellchecknpm run spellcheck—{“contents”:“read”}
lint-code / Lint codenpm run lint:code — —format github—{“contents”:“read”}
lint-styles / Lint stylesnpm run lint:css—{“contents”:“read”}
lint-markdown / Lint Markdownnpm run lint:markdown—{“contents”:“read”}
audit-unused / Audit unused codenpm run audit:unused—{“contents”:“read”}
typecheck / Type-checknpm run typecheck—{“contents”:“read”}
unit-tests / Unit tests and coveragenpm run test:coverage—website-unit-coverage{“contents”:“read”}
build / Production buildnpm run buildformat, lint-code, lint-styles, lint-markdown, spellcheck, audit-unused, typecheck, unit-testswebsite-build; website/dist{“contents”:“read”}
validate-build / Validate buildnpm run validate:buildbuildwebsite-build{“contents”:“read”}
browser-tests / Browser and accessibility testsInstall supported browsers; npm run test:e2ebuildwebsite-build; browser-test-results{“contents”:“read”}
lighthouse / Lighthouse budgetsInstall Lighthouse browser; npm run lighthouse:cibuildwebsite-build; lighthouse-reports{“contents”:“read”}
deploy / Deploy GitHub PagesDeploy GitHub Pagesformat, lint-code, lint-styles, lint-markdown, spellcheck, audit-unused, typecheck, unit-tests, build, validate-build, browser-tests, lighthouse{“pages”:“write”,“id-token”:“write”}
smoke-deployed / Verify deployed websiteInstall Chromium; npm run test:smokedeploywebsite-deployed-smoke-results{“contents”:“read”}

GitLab native jobs

Root pipeline rules and include scopes are described above; all includes run under the same pipeline. Images select independent Node versions; no GitHub token permissions apply. GitLab CI job-token access and protected variables are server settings whose live state was not inspected.

Source: generator.yml.

Job IDCommandsNeedsArtifacts
generator-packagenpm run build —workspace @rm-industries/create-forge; npm pack —ignore-scripts —workspace @rm-industries/create-forge —pack-destination “$CI_PROJECT_DIR/.ci-packages”.ci-packages/create-forge.tgz
consumer-primarymkdir -p “/tmp/forge-cli”; cd /tmp/forge-consumer; npm ci; node “$CI_PROJECT_DIR/scripts/verify-consumer-lock.ts” /tmp/forge-consumer; npm run typecheck; npm run test:coverage; else npm test; fi; npm run buildgenerator-package.ci-consumer/consumer-source.tgz, .ci-consumer/dist, .ci-consumer/coverage, .ci-consumer/test-results/unit.xml
consumer-compatibilitymkdir -p “/tmp/forge-cli”; cd /tmp/forge-consumer; npm ci; node “$CI_PROJECT_DIR/scripts/verify-consumer-lock.ts” /tmp/forge-consumer; npm run typecheck; npm run test:coverage; else npm test; fi; npm run buildgenerator-package.ci-consumer/test-results/unit.xml
consumer-qualitynpm run format && npm run lint && npm run audit:unusedconsumer-primary—
consumer-validate-buildcp -R “$CI_PROJECT_DIR/.ci-consumer/dist” .; npm run validate:buildconsumer-primary—
consumer-browsercp -R “$CI_PROJECT_DIR/.ci-consumer/dist” .; npx playwright install —with-deps chromium firefox webkit; npm run test:e2econsumer-primary.ci-consumer/playwright-report, .ci-consumer/test-results
consumer-lighthousecp -R “$CI_PROJECT_DIR/.ci-consumer/dist” .; npx playwright install —with-deps chromium; export CHROME_PATH=”$(node —input-type=module -e ‘import { chromium } from “@playwright/test”; process.stdout.write(chromium.executablePath());’)”; npm run lighthouse:ciconsumer-primary.ci-consumer/.lighthouseci
generator-scenariosFORGE_CLI_TARBALL=“$CI_PROJECT_DIR/.ci-packages/create-forge.tgz” node packages/create-forge/scripts/test-generator-e2e.tsgenerator-package—
consumer-quality-tool-regressionsnpm run verify:template:static—

Source: project.yml.

Job IDCommandsNeedsArtifacts
project-formatnpm run format—
project-lint-codemkdir -p test-results; npm run lint:code —silent — —format gitlab > test-results/code-quality.jsontest-results/code-quality.json
project-lint-markdownnpm run lint:markdown—
project-spellchecknpm run spellcheck—
project-documentationnpm run docs:validate—
project-typechecknpm run typecheck:root—
project-testnpm run test:roottest-results/unit.xml
project-nativenpm run quality:native —workspace @rm-industries/browser-oxfmt—
project-buildnpm run build; mkdir -p .ci-packages; npm pack —ignore-scripts —workspaces —pack-destination .ci-packagesproject-format, project-lint-code, project-lint-markdown, project-spellcheck, project-documentation, project-typecheck, project-test, project-nativepackages/browser-oxfmt/dist, packages/content-model/dist, packages/create-forge/dist, .ci-packages
project-packfor candidate in .ci-packages/*.tgz; doproject-build—
project-compatibilitycp -R packages/browser-oxfmt/dist/generated packages/browser-oxfmt/src/generated; tar -xOf .ci-packages/browser-oxfmt.tgz package/NOTICE.md > packages/browser-oxfmt/NOTICE.md; npm run typecheck:workspaces && npm run test:workspaces; mkdir -p “/tmp/content-model-check”project-buildpackages/*/test-results/unit.xml

Source: website.yml.

Job IDCommandsNeedsArtifacts
website-formatnpm run format—
website-spellchecknpm run spellcheck—
website-lint-codemkdir -p test-results; npm run lint:code —silent — —format gitlab > test-results/code-quality.json || status=$?website/test-results/code-quality.json
website-lint-stylesnpm run lint:css—
website-lint-markdownnpm run lint:markdown—
website-audit-unusednpm run audit:unused—
website-typechecknpm run typecheck—
website-unit-testsnpm run test:coveragewebsite/coverage, website/test-results/unit.xml
website-buildnpm run buildwebsite-format, website-spellcheck, website-lint-code, website-lint-styles, website-lint-markdown, website-audit-unused, website-typecheck, website-unit-testswebsite/dist
website-validate-buildnpm run validate:buildwebsite-build—
website-browser-testsnpx playwright install —with-deps chromium firefox webkit; npm run test:e2ewebsite-buildwebsite/playwright-report, website/test-results
website-lighthousenpx playwright install —with-deps chromium; export CHROME_PATH=”$(node —input-type=module -e ‘import { chromium } from “@playwright/test”; process.stdout.write(chromium.executablePath());’)”; npm run lighthouse:ciwebsite-buildwebsite/.lighthouseci
website-deploytest -f ‘website/dist/index.html’website-format, website-spellcheck, website-lint-code, website-lint-styles, website-lint-markdown, website-audit-unused, website-typecheck, website-unit-tests, website-build, website-validate-build, website-browser-tests, website-lighthousewebsite/dist
website-smoke-deployedtest -n “$CI_PAGES_URL”; npx playwright install —with-deps chromium; npm run test:smokewebsite-deploywebsite/playwright-report, website/test-results

Generated provider inventory

The bootstrap authors github.ts, github-extra.ts, gitlab.ts and model.ts are the authoritative source. The default generated GitHub set is project.yml, automation.yml, security.yml; a prefix names them for nested sites. GitLab emits .gitlab-ci.yml, or a prefixed include under .gitlab/ci. Consumer YAML has no continuing generator requirement.

OutputJobs and commandsTrigger / authority / artifacts
GitHub projectformat, spellcheck, lint-code, lint-styles, lint-markdown, audit-unused, typecheck, unit-tests, build, validate-build, browser-tests, lighthouse; public siteWork commands match the native website tablePR/push configured branches; optional nested-directory paths; read contents; workflow-ref/ref concurrency; coverage, dist, Pages, browser and Lighthouse artifacts
GitHub deployment extrasdeploy, smoke-deployed or environment-suffixed equivalents; Pages deploy or locked Wrangler, then test:smokePrimary-provider branch pushes only; Pages/OIDC write only where required; environment-scoped destination; consume inspected production build
GitHub automationsecurity, syntax: Zizmor and actionlintWorkflow changes and weekly Monday schedule, manual; contents read, security-events write for scanner
GitHub securitycode-analysis Actions/JS matrix and dependency-reviewPR/push and weekly Monday; dependency review PR only; actions/contents read and security-events write
GitLab consumerSame siteWork quality/build/browser/Lighthouse responsibilities, provider-native reports; deployment and smoke only for selected primary targetMR/default or configured branch push; duplicate pipeline suppression; interruptible jobs; JUnit/Cobertura/Code Quality and build/browser/Lighthouse artifacts

Schedules use bootstrap-derived minutes to avoid identical timing across repositories. Primary GitHub cannot deploy GitLab Pages and primary GitLab cannot deploy GitHub Pages. Cloudflare uses locked Wrangler, environment secrets and account/project validation. Root/nested directory, selected Node major, provider, source branch and multiple deployment environment combinations are validated through existing packed-CLI scenarios and provider contracts. Generated workflow live protections and successful provider execution remain unavailable until inspected in each consumer; emitted structure alone is insufficient.

During rollout retain every existing required job name above, reporting a successful no-op for unaffected work. Add summaries alongside those contexts; the proposed migration table does not authorize renaming or removing required jobs before the owner approves a protection change.