eg

1
siivous
2026-06-15 13:51:33 +03:00 · 2026-06-15 13:48:39 +03:00 · 2026-06-15 13:39:36 +03:00 · 2026-06-15 13:35:14 +03:00 · 2026-06-15 13:26:08 +03:00 · 2026-06-15 13:21:49 +03:00
39 changed files with 1644 additions and 1948 deletions
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SHA8="${GITHUB_SHA:0:8}"
+REPORTS_DIR="reports/${SHA8}"
+
+mkdir -p "${REPORTS_DIR}"
+
+BATS_PASS=$(grep -c 'ok' "${REPORTS_DIR}/bats/results.txt" 2>/dev/null || echo 0)
+BATS_FAIL=$(grep -c 'not ok' "${REPORTS_DIR}/bats/results.txt" 2>/dev/null || echo 0)
+CUCUMBER_PASS=$(jq '.summary.passed // 0' "${REPORTS_DIR}/cucumber/report.json" 2>/dev/null || echo 0)
+CUCUMBER_FAIL=$(jq '.summary.failed // 0' "${REPORTS_DIR}/cucumber/report.json" 2>/dev/null || echo 0)
+
+{
+  echo "<!DOCTYPE html><html><head><meta charset='utf-8'>"
+  echo "<title>CI report ${SHA8}</title>"
+  echo "<style>body{font-family:sans-serif;margin:2em}a{color:#2563eb}table{border-collapse:collapse}"
+  echo "th,td{border:1px solid #ccc;padding:8px;text-align:left}"
+  echo ".pass{color:#059669}.fail{color:#dc2626}</style></head><body>"
+  echo "<h1>CI report <code>${SHA8}</code></h1>"
+  echo "<p>Commit: ${GITHUB_SHA}<br>Branch: ${GITHUB_REF_NAME}<br>Run: ${GITHUB_RUN_ID}</p>"
+  echo "<table><tr><th>Suite</th><th>Passed</th><th>Failed</th><th>Report</th></tr>"
+  echo "<tr><td>Bats</td><td class='pass'>${BATS_PASS}</td><td class='fail'>${BATS_FAIL}</td>"
+  echo "<td><a href='bats/results.txt'>results.txt</a>"
+  echo " | <a href='bats/junit.xml'>junit.xml</a></td></tr>"
+  echo "<tr><td>Cucumber</td><td class='pass'>${CUCUMBER_PASS}</td><td class='fail'>${CUCUMBER_FAIL}</td>"
+  echo "<td><a href='cucumber/index.html'>report</a>"
+  echo " | <a href='cucumber/report.json'>json</a></td></tr>"
+  echo "</table></body></html>"
+} > "${REPORTS_DIR}/index.html"
@@ -0,0 +1,330 @@
+name: Build & Publish Artifact
+on:
+  workflow_call:
+    inputs:
+      env_json:
+        required: true
+        type: string
+      bats-image:
+        required: true
+        type: string
+      cucumber-node-image:
+        required: true
+        type: string
+    secrets:
+      GITEA_TOKEN:
+        required: true
+      GIT_PAGES_PUBLISH_TOKEN:
+        required: true
+      DOCKER_USERNAME:
+        required: false
+      DOCKER_PASSWORD:
+        required: true
+
+env:
+  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
+  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
+  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
+  REPO: ${{ github.repository }}
+  DOCKER_REGISTRY: ${{ fromJson(inputs.env_json).DOCKER_REGISTRY || '' }}
+  DOCKER_IMAGE_NAME: ${{ fromJson(inputs.env_json).DOCKER_IMAGE_NAME || '' }}
+  DOCKER_UI_URL: ${{ fromJson(inputs.env_json).DOCKER_UI_URL || '' }}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    outputs:
+      artifact_exists: ${{ steps.set-outputs.outputs.artifact_exists }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set Gitea status to PENDING
+        run: |
+          echo "===== gitea-ci-library - Check existing artifact | begin ====="
+          bash scripts/report-status.sh pending "Checking version..." ci-check
+
+      - name: Check existing artifact and calculate version
+        run: |
+          RAW_VERSION=$(jq -r '.version' package.json)
+          BASE_VERSION=$(echo "$RAW_VERSION" | cut -d'.' -f1-2)
+          echo "gitea-ci-library - Tunnistettu Major.Minor versio: $BASE_VERSION"
+
+          TAGS_JSON=$(curl -s -f -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            "${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}/tags")
+
+          TAG=$(echo "$TAGS_JSON" | jq -r 'if type == "array" then .[] | select(.commit.sha == "${{ github.sha }}") | .name else empty end' | head -1)
+
+          mkdir -p /tmp/build-ctx
+
+          if [ -n "$TAG" ]; then
+            echo "ARTIFACT_EXISTS=true" > /tmp/build-ctx/build.env
+            echo "NEXT_VERSION=$TAG" >> /tmp/build-ctx/build.env
+            echo "gitea-ci-library - Artefakti löytyi jo tagilla: $TAG."
+          else
+            echo "ARTIFACT_EXISTS=false" > /tmp/build-ctx/build.env
+            
+            HIGHEST_PATCH=$(echo "$TAGS_JSON" | jq -r --arg bv "$BASE_VERSION." '
+              if type == "array" then .[] | .name | select(startswith($bv)) | sub($bv; "") | tonumber else empty end' | sort -rn | head -1)
+
+            if [ -z "$HIGHEST_PATCH" ]; then NEXT_PATCH=0; else NEXT_PATCH=$((HIGHEST_PATCH + 1)); fi
+            FULL_VERSION="${BASE_VERSION}.${NEXT_PATCH}"
+            
+            echo "NEXT_VERSION=$FULL_VERSION" >> /tmp/build-ctx/build.env
+            echo "gitea-ci-library - Uusi vapaa versio: $FULL_VERSION"
+          fi
+
+      - name: Set job outputs
+        id: set-outputs
+        run: |
+          source /tmp/build-ctx/build.env
+          echo "artifact_exists=$ARTIFACT_EXISTS" >> "$GITHUB_OUTPUT"
+
+      - name: Upload build env artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: build-context
+          path: /tmp/build-ctx/build.env
+          retention-days: 1
+
+      - name: Set Gitea status to SUCCESS
+        if: success()
+        run: |
+          source /tmp/build-ctx/build.env
+          if [ "${ARTIFACT_EXISTS}" = "true" ]; then
+            bash scripts/report-status.sh success "Skip build: version $NEXT_VERSION exists" ci-check
+          else
+            bash scripts/report-status.sh success "Build version $NEXT_VERSION required" ci-check
+          fi
+
+      - name: Set Gitea status to FAILURE
+        if: failure()
+        run: bash scripts/report-status.sh failure "Check version FAILED" ci-check
+
+  # quality-gate:
+  #   needs: [check]
+  #   uses: niko/gitea-ci-library/.gitea/workflows/quality-gate.yml@main
+  #   secrets: inherit
+  #   with:
+  #     env_json: ${{ inputs.env_json }}
+  #     bats-image: ${{ inputs.bats-image }}
+  #     cucumber-node-image: ${{ inputs.cucumber-node-image }}
+
+  build:
+    runs-on: ubuntu-latest
+    # needs: [check, quality-gate]
+    needs: [check]
+    # Skipataan koko build jos artefakti löytyy jo
+    if: needs.check.outputs.artifact_exists != 'true'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download build env
+        uses: actions/download-artifact@v3
+        with:
+          name: build-context
+          path: /tmp/build-ctx
+
+      - name: Check if build needed
+        id: gatekeeper
+        run: |
+          source /tmp/build-ctx/build.env
+          if [ "${ARTIFACT_EXISTS}" = "true" ]; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Set Gitea status to PENDING
+        if: steps.gatekeeper.outputs.skip == 'false'
+        run: |
+          echo "===== gitea-ci-library - Docker Build | begin ====="
+          bash scripts/report-status.sh pending "Building Docker image..." ci-docker-build
+
+      - name: Build container
+        if: steps.gatekeeper.outputs.skip == 'false'
+        run: |
+          source /tmp/build-ctx/build.env
+          NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+          docker build \
+            --label "git.commit=${{ github.sha }}" \
+            --label "git.commitBy=${{ github.actor }}" \
+            --label "build.date=${NOW}" \
+            -t "${DOCKER_IMAGE_NAME}:${NEXT_VERSION}" .
+
+      - name: Report status SUCCESS
+        if: steps.gatekeeper.outputs.skip == 'false' && success()
+        run: |
+          source /tmp/build-ctx/build.env
+          bash scripts/report-status.sh success "Docker build $NEXT_VERSION OK" ci-docker-build
+
+      - name: Report status FAILURE
+        if: steps.gatekeeper.outputs.skip == 'false' && failure()
+        run: |
+          source /tmp/build-ctx/build.env
+          bash scripts/report-status.sh failure "Docker build $NEXT_VERSION FAILED" ci-docker-build
+
+      - name: Save Docker image
+        if: steps.gatekeeper.outputs.skip == 'false' && success()
+        run: |
+          source /tmp/build-ctx/build.env
+          mkdir -p /tmp/image
+          docker save "${DOCKER_IMAGE_NAME}:${NEXT_VERSION}" -o /tmp/image/artifact.tar
+
+      - name: Upload Docker image artifact
+        if: steps.gatekeeper.outputs.skip == 'false' && success()
+        uses: actions/upload-artifact@v3
+        with:
+          name: docker-image
+          path: /tmp/image/artifact.tar
+          retention-days: 0
+
+  push:
+    runs-on: ubuntu-latest
+    needs: [check, build]
+    if: needs.check.outputs.artifact_exists != 'true'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download build env
+        uses: actions/download-artifact@v3
+        with:
+          name: build-context
+          path: /tmp/build-ctx
+
+      - name: Verify Build Status
+        id: gatekeeper
+        run: |
+          BUILD_RESULT="${{ needs.build.result }}"
+          source /tmp/build-ctx/build.env
+          if [ "$BUILD_RESULT" != "success" ]; then
+            echo "gitea-ci-library - Edellinen vaihe epäonnistui. Keskeytetään." >&2
+            exit 1
+          fi
+          if [ "${ARTIFACT_EXISTS}" = "true" ]; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Load saved Docker image
+        if: steps.gatekeeper.outputs.skip == 'false'
+        uses: actions/download-artifact@v3
+        with:
+          name: docker-image
+          path: /tmp/image
+
+      - name: Set Gitea status to PENDING
+        if: steps.gatekeeper.outputs.skip == 'false'
+        run: |
+          echo "===== gitea-ci-library - Docker Push | begin ====="
+          bash scripts/report-status.sh pending "Pushing to registry..." ci-docker-push
+
+      - name: Push to Docker Registry
+        if: steps.gatekeeper.outputs.skip == 'false'
+        env:
+          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME || github.actor }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+        run: |
+          source /tmp/build-ctx/build.env
+          docker load -i /tmp/image/artifact.tar
+
+          REGISTRY="${DOCKER_REGISTRY:?DOCKER_REGISTRY not set in env.conf}"
+          IMAGE="${DOCKER_IMAGE_NAME:?DOCKER_IMAGE_NAME not set in env.conf}"
+          REGISTRY_HOST="${REGISTRY%%/*}"
+
+          FULL_IMAGE="${REGISTRY}/${IMAGE}:${NEXT_VERSION}"
+          echo "Pushing ${FULL_IMAGE} ..."
+
+          docker tag "${DOCKER_IMAGE_NAME}:${NEXT_VERSION}" "$FULL_IMAGE"
+          echo "$DOCKER_PASSWORD" | docker login "$REGISTRY_HOST" -u "$DOCKER_USERNAME" --password-stdin
+          docker push "$FULL_IMAGE"
+          docker logout "$REGISTRY_HOST"
+
+      - name: Report status SUCCESS
+        if: steps.gatekeeper.outputs.skip == 'false' && success()
+        run: |
+          source /tmp/build-ctx/build.env
+          CONTAINER_URL=""
+          if [ -n "${DOCKER_UI_URL:-}" ] && [ -n "${NEXT_VERSION:-}" ]; then
+            CONTAINER_URL="${DOCKER_UI_URL}/${NEXT_VERSION}"
+          fi
+          bash scripts/report-status.sh success "Docker push $NEXT_VERSION OK" ci-docker-push "" "$CONTAINER_URL"
+
+      - name: Report status FAILURE
+        if: steps.gatekeeper.outputs.skip == 'false' && failure()
+        run: |
+          source /tmp/build-ctx/build.env
+          bash scripts/report-status.sh failure "Docker push $NEXT_VERSION FAILED" ci-docker-push
+
+  tag-commit:
+    runs-on: ubuntu-latest
+    needs: [check, push]
+    if: needs.check.outputs.artifact_exists != 'true'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download build env
+        uses: actions/download-artifact@v3
+        with:
+          name: build-context
+          path: /tmp/build-ctx
+
+      - name: Verify Push Status
+        id: gatekeeper
+        run: |
+          PUSH_RESULT="${{ needs.push.result }}"
+          source /tmp/build-ctx/build.env
+          if [ "$PUSH_RESULT" != "success" ]; then
+            echo "gitea-ci-library - Push vaihe epäonnistui. Keskeytetään." >&2
+            exit 1
+          fi
+          if [ "${ARTIFACT_EXISTS}" = "true" ]; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Set Gitea status to PENDING
+        if: steps.gatekeeper.outputs.skip == 'false'
+        run: |
+          echo "===== gitea-ci-library - Create Tag | begin ====="
+          bash scripts/report-status.sh pending "Creating tag..." ci-docker-tag
+
+      - name: Create git tag
+        if: steps.gatekeeper.outputs.skip == 'false'
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          REPO: ${{ github.repository }}
+          SERVER_URL: ${{ gitea.server_url }}
+          RUN_NUMBER: ${{ github.run_number }}
+          SHA: ${{ github.sha }}
+        run: |
+          source /tmp/build-ctx/build.env
+          HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
+            "$SERVER_URL/api/v1/repos/$REPO/tags" \
+            -H "Authorization: token $GITEA_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{\"tag_name\": \"$NEXT_VERSION\", \"message\": \"Build #$RUN_NUMBER\", \"target\": \"$SHA\"}")
+
+          if [ "$HTTP_CODE" = "201" ] || [ "$HTTP_CODE" = "409" ]; then
+            exit 0
+          else
+            exit 1
+          fi
+
+      - name: Report status SUCCESS
+        if: steps.gatekeeper.outputs.skip == 'false' && success()
+        run: |
+          source /tmp/build-ctx/build.env
+          bash scripts/report-status.sh success "Tag $NEXT_VERSION OK" ci-docker-tag
+
+      - name: Report status FAILURE
+        if: steps.gatekeeper.outputs.skip == 'false' && failure()
+        run: |
+          source /tmp/build-ctx/build.env
+          bash scripts/report-status.sh failure "Tag $NEXT_VERSION FAILED" ci-docker-tag
@@ -1,73 +0,0 @@
-name: Check Existing Artifact
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-    outputs:
-      artifact_exists:
-        value: ${{ jobs.check.outputs.artifact_exists }}
-      version:
-        value: ${{ jobs.check.outputs.version }}
-
-env:
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    outputs:
-      artifact_exists: ${{ steps.set-outputs.outputs.artifact_exists }}
-      version: ${{ steps.set-outputs.outputs.version }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Check existing artifact and calculate version
-        run: |
-          if [ -f VERSION ]; then
-            RAW_VERSION=$(cat VERSION | tr -d '[:space:]')
-          elif [ -f package.json ]; then
-            RAW_VERSION=$(jq -r '.version' package.json)
-          elif [ -f pom.xml ]; then
-            RAW_VERSION=$(grep -oP '<version>\K[^<]+' pom.xml | head -1)
-          else
-            echo "ERROR: No VERSION file, package.json, or pom.xml found" >&2
-            exit 1
-          fi
-          BASE_VERSION=$(echo "$RAW_VERSION" | cut -d'.' -f1-2)
-          echo "gitea-ci-library - Tunnistettu Major.Minor versio: $BASE_VERSION"
-
-          TAGS_JSON=$(curl -s -f -H "Authorization: token $GITEA_TOKEN" \
-            "${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}/tags")
-
-          TAG=$(echo "$TAGS_JSON" | jq -r 'if type == "array" then .[] | select(.commit.sha == "${{ github.sha }}") | .name else empty end' | head -1)
-
-          mkdir -p /tmp/build-ctx
-
-          if [ -n "$TAG" ]; then
-            echo "ARTIFACT_EXISTS=true" > /tmp/build-ctx/build.env
-            echo "NEXT_VERSION=$TAG" >> /tmp/build-ctx/build.env
-            echo "gitea-ci-library - Artefakti löytyi jo tagilla: $TAG."
-          else
-            echo "ARTIFACT_EXISTS=false" > /tmp/build-ctx/build.env
-
-            HIGHEST_PATCH=$(echo "$TAGS_JSON" | jq -r --arg bv "$BASE_VERSION." '
-              if type == "array" then .[] | .name | select(startswith($bv)) | sub($bv; "") | tonumber else empty end' | sort -rn | head -1)
-
-            if [ -z "$HIGHEST_PATCH" ]; then NEXT_PATCH=0; else NEXT_PATCH=$((HIGHEST_PATCH + 1)); fi
-            FULL_VERSION="${BASE_VERSION}.${NEXT_PATCH}"
-
-            echo "NEXT_VERSION=$FULL_VERSION" >> /tmp/build-ctx/build.env
-            echo "gitea-ci-library - Uusi vapaa versio: $FULL_VERSION"
-          fi
-
-      - name: Set job outputs
-        id: set-outputs
-        run: |
-          source /tmp/build-ctx/build.env
-          echo "artifact_exists=$ARTIFACT_EXISTS" >> "$GITHUB_OUTPUT"
-          echo "version=$NEXT_VERSION" >> "$GITHUB_OUTPUT"
@@ -1,57 +0,0 @@
-name: CI Container Build & Push
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-      dockerfile_path:
-        required: true
-        type: string
-      image_name:
-        required: true
-        type: string
-      tag:
-        required: true
-        type: string
-    secrets:
-      DOCKER_USERNAME:
-        required: false
-      DOCKER_PASSWORD:
-        required: true
-
-env:
-  DOCKER_REGISTRY: ${{ fromJson(inputs.env_json).DOCKER_REGISTRY || '' }}
-  IMAGE_NAME: ${{ inputs.image_name }}
-  TAG: ${{ inputs.tag }}
-  DOCKERFILE: ${{ inputs.dockerfile_path }}
-
-jobs:
-  build-push:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Build and push CI container
-        env:
-          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME || github.actor }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-        run: |
-          NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-          docker build \
-            --label "git.commit=${{ github.sha }}" \
-            --label "git.commitBy=${{ github.actor }}" \
-            --label "build.date=${NOW}" \
-            -f "${DOCKERFILE}" \
-            -t "${IMAGE_NAME}:${TAG}" .
-
-          REGISTRY="${DOCKER_REGISTRY:?DOCKER_REGISTRY not set in env.conf}"
-          REGISTRY_HOST="${REGISTRY%%/*}"
-
-          FULL_IMAGE="${REGISTRY}/${IMAGE_NAME}:${TAG}"
-          echo "Pushing ${FULL_IMAGE} ..."
-
-          docker tag "${IMAGE_NAME}:${TAG}" "$FULL_IMAGE"
-          echo "$DOCKER_PASSWORD" | docker login "$REGISTRY_HOST" -u "$DOCKER_USERNAME" --password-stdin
-          docker push "$FULL_IMAGE"
-          docker logout "$REGISTRY_HOST"
@@ -0,0 +1,34 @@
+name: CI
+on:
+  push:
+    branches: ["**"]
+  workflow_dispatch:
+
+jobs:
+  load-config:
+    name: Load gitea-env.conf to pipeline env
+    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
+    with:
+      config_path: .gitea/workflows/gitea-env.conf
+
+  # feature:
+  #   name: Quality Gate
+  #   if: github.ref != 'refs/heads/main'
+  #   needs: [load-config]
+  #   uses: niko/gitea-ci-library/.gitea/workflows/quality-gate.yml@main
+  #   secrets: inherit
+  #   with:
+  #     env_json: ${{ needs.load-config.outputs.env_json }}
+  #     bats-image: bats/bats:latest
+  #     cucumber-node-image: node:22
+
+  main:
+    name: Build & Push Artifact
+    # if: github.ref == 'refs/heads/main'  # FIXME: väliaikainen — ajetaan tässä haarassa
+    needs: [load-config]
+    uses: niko/gitea-ci-library/.gitea/workflows/build_publish-artifact.yml@feature/docker-kuntoon
+    secrets: inherit
+    with:
+      env_json: ${{ needs.load-config.outputs.env_json }}
+      bats-image: bats/bats:latest
+      cucumber-node-image: node:22
@@ -1,41 +1,21 @@
-name: Config Provider
+name: Config Provider Library
 on:
  workflow_call:
    inputs:
      config_path:
        required: true
        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-      GIT_PAGES_PUBLISH_TOKEN:
-        required: true
    outputs:
      env_json:
        value: ${{ jobs.parse-config.outputs.json_data }}
-      config_path:
-        value: ${{ jobs.parse-config.outputs.config_path }}
-
-env:
-  CI_CONF_FILE: ${{ inputs.config_path }}
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}

 jobs:
  parse-config:
    runs-on: ubuntu-latest
    outputs:
      json_data: ${{ steps.convert.outputs.JSON_OUT }}
-      config_path: ${{ steps.set-path.outputs.CONFIG_PATH }}
    steps:
      - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: niko/gitea-ci-library
-          path: .ci
-
-      - name: Validate CI config
-        run: bash .ci/scripts/ci-validate.sh

      - id: convert
        run: |
@@ -49,6 +29,3 @@ jobs:

          CLEAN_JSON=$(echo "$JSON_STRING" | jq -c .)
          echo "JSON_OUT=$CLEAN_JSON" >> "$GITHUB_OUTPUT"
-
-      - id: set-path
-        run: echo "CONFIG_PATH=${{ inputs.config_path }}" >> "$GITHUB_OUTPUT"
@@ -1,103 +0,0 @@
-name: Docker Build & Push
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-      version:
-        required: true
-        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-      DOCKER_USERNAME:
-        required: false
-      DOCKER_PASSWORD:
-        required: true
-
-env:
-  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-  DOCKER_REGISTRY: ${{ fromJson(inputs.env_json).DOCKER_REGISTRY || '' }}
-  DOCKER_IMAGE_NAME: ${{ fromJson(inputs.env_json).DOCKER_IMAGE_NAME || '' }}
-  DOCKER_UI_URL: ${{ fromJson(inputs.env_json).DOCKER_UI_URL || '' }}
-  DOCKERFILE: ${{ fromJson(inputs.env_json).DOCKERFILE || 'Dockerfile' }}
-  VERSION: ${{ inputs.version }}
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build-push:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: niko/gitea-ci-library
-          path: .ci
-
-      - name: Build and push container
-        env:
-          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME || github.actor }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-        run: |
-          NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-          docker build \
-            --label "git.commit=${{ github.sha }}" \
-            --label "git.commitBy=${{ github.actor }}" \
-            --label "build.date=${NOW}" \
-            -f "${DOCKERFILE}" \
-            -t "${DOCKER_IMAGE_NAME}:${VERSION}" .
-
-          REGISTRY="${DOCKER_REGISTRY:?DOCKER_REGISTRY not set in env.conf}"
-          IMAGE="${DOCKER_IMAGE_NAME:?DOCKER_IMAGE_NAME not set in env.conf}"
-          REGISTRY_HOST="${REGISTRY%%/*}"
-
-          FULL_IMAGE="${REGISTRY}/${IMAGE}:${VERSION}"
-          echo "Pushing ${FULL_IMAGE} ..."
-
-          docker tag "${DOCKER_IMAGE_NAME}:${VERSION}" "$FULL_IMAGE"
-          echo "$DOCKER_PASSWORD" | docker login "$REGISTRY_HOST" -u "$DOCKER_USERNAME" --password-stdin
-          docker push "$FULL_IMAGE"
-          docker logout "$REGISTRY_HOST"
-
-      - name: Report status SUCCESS
-        if: success()
-        run: |
-          CONTAINER_URL=""
-          if [ -n "${DOCKER_UI_URL:-}" ] && [ -n "${VERSION:-}" ]; then
-            CONTAINER_URL="${DOCKER_UI_URL}/${VERSION}"
-          fi
-          bash .ci/scripts/report-status.sh success "Docker build & push ${VERSION} OK" ci-docker-build-push "" "$CONTAINER_URL"
-
-      - name: Report status FAILURE
-        if: failure()
-        run: bash .ci/scripts/report-status.sh failure "Docker build & push ${VERSION} FAILED" ci-docker-build-push
-
-  tag-commit:
-    runs-on: ubuntu-latest
-    needs: [build-push]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Create git tag
-        env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-          SERVER_URL: ${{ gitea.server_url }}
-          RUN_NUMBER: ${{ github.run_number }}
-          SHA: ${{ github.sha }}
-        run: |
-          HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
-            "$SERVER_URL/api/v1/repos/${{ github.repository }}/tags" \
-            -H "Authorization: token $GITEA_TOKEN" \
-            -H "Content-Type: application/json" \
-            -d "{\"tag_name\": \"${VERSION}\", \"message\": \"Build #$RUN_NUMBER\", \"target\": \"$SHA\"}")
-
-          if [ "$HTTP_CODE" = "201" ] || [ "$HTTP_CODE" = "409" ]; then
-            exit 0
-          else
-            exit 1
-          fi
@@ -1,64 +0,0 @@
-name: Bats Tests
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-      bats-image:
-        required: true
-        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-      GIT_PAGES_PUBLISH_TOKEN:
-        required: true
-
-env:
-  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
-  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
-
-jobs:
-  bats:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: niko/gitea-ci-library
-          path: .ci
-
-      - name: Run bats tests
-        id: bats-tests
-        shell: bash
-        run: |
-          docker volume create bats-workspace
-          tar c . | docker run --rm -i -v bats-workspace:/data alpine tar x -C /data
-          mkdir -p "reports/${GITHUB_SHA:0:8}/bats"
-          set +e
-          docker run --rm \
-            -v bats-workspace:/data \
-            --entrypoint bash ${{ inputs.bats-image }} \
-            -c 'cd /data && bashcov -- bats tests/' \
-            > "reports/${GITHUB_SHA:0:8}/bats/results.txt" 2>&1
-          BATS_EXIT=$?
-          bash .ci/.gitea/scripts/bats-coverage.sh bats-workspace "reports/${GITHUB_SHA:0:8}/bats"
-          docker volume rm bats-workspace > /dev/null 2>&1
-          bash .ci/.gitea/scripts/bats-report.sh "reports/${GITHUB_SHA:0:8}/bats"
-          echo "BATS_EXIT=${BATS_EXIT}" >> "${GITHUB_ENV}"
-          exit ${BATS_EXIT}
-
-      - name: Publish bats reports
-        if: always()
-        run: bash .ci/scripts/publish-git-pages.sh bats
-
-      - name: Report status
-        if: always()
-        run: |
-          if [ "${BATS_EXIT}" = "0" ]; then
-            bash .ci/scripts/report-status.sh success "Link to Bats reports" unit-tests bats
-          else
-            bash .ci/scripts/report-status.sh failure "Link to Bats reports" unit-tests bats
-          fi
@@ -1,21 +0,0 @@
-name: Build CI Bats Container (Manual)
-on: workflow_dispatch
-
-jobs:
-  load-config:
-    name: Load config
-    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/example-gitea-env.conf
-
-  build-push:
-    name: Build & Push
-    needs: [load-config]
-    uses: niko/gitea-ci-library/.gitea/workflows/ci-container-build-push.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      dockerfile_path: Dockerfile.ci-bats
-      image_name: ci-bats
-      tag: latest
@@ -1,21 +0,0 @@
-name: Build CI Cucumber Container (Manual)
-on: workflow_dispatch
-
-jobs:
-  load-config:
-    name: Load config
-    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/example-gitea-env.conf
-
-  build-push:
-    name: Build & Push
-    needs: [load-config]
-    uses: niko/gitea-ci-library/.gitea/workflows/ci-container-build-push.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      dockerfile_path: Dockerfile.ci-cucumber
-      image_name: ci-cucumber
-      tag: latest
@@ -1,68 +0,0 @@
-name: Cucumber Tests
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-      cucumber-node-image:
-        required: true
-        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-      GIT_PAGES_PUBLISH_TOKEN:
-        required: true
-
-env:
-  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
-  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
-
-jobs:
-  cucumber:
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ inputs.cucumber-node-image }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: niko/gitea-ci-library
-          path: .ci
-
-      - name: Run cucumber tests
-        id: cucumber-tests
-        shell: bash
-        run: |
-          mkdir -p "reports/${GITHUB_SHA:0:8}/cucumber"
-          set +e
-          npx cucumber-js \
-            --format json:"reports/${GITHUB_SHA:0:8}/cucumber/report.json" \
-            --format html:"reports/${GITHUB_SHA:0:8}/cucumber/index.html" 2>&1
-          CUCUMBER_EXIT=$?
-          echo "CUCUMBER_EXIT=${CUCUMBER_EXIT}" >> "${GITHUB_ENV}"
-          exit ${CUCUMBER_EXIT}
-
-      - name: Publish cucumber reports
-        if: always()
-        run: bash .ci/scripts/publish-git-pages.sh cucumber
-
-      - name: Report status
-        if: always()
-        shell: bash
-        run: |
-          if [ "${CUCUMBER_EXIT}" = "0" ]; then
-            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
-              bash .ci/scripts/report-status.sh success "Link to Cucumber reports" acc-tests cucumber
-            else
-              bash .ci/scripts/report-status.sh success "Link to Cucumber reports" acc-tests
-            fi
-          else
-            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
-              bash .ci/scripts/report-status.sh failure "Link to Cucumber reports" acc-tests cucumber
-            else
-              bash .ci/scripts/report-status.sh failure "Link to Cucumber reports" acc-tests
-            fi
-          fi
@@ -1,41 +0,0 @@
-name: CI Feature
-on:
-  push:
-    branches-ignore:
-      - main
-  workflow_dispatch:
-
-jobs:
-  load-config:
-    name: Load example-gitea-env.conf to pipeline env
-    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/example-gitea-env.conf
-
-  bats:
-    name: Bats tests
-    needs: [load-config]
-    uses: niko/gitea-ci-library/.gitea/workflows/example-bats-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      bats-image: gitea.app.keskikuja.site/niko/ci-bats:latest
-
-  cucumber:
-    name: Cucumber tests
-    needs: [load-config]
-    uses: niko/gitea-ci-library/.gitea/workflows/example-cucumber-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      cucumber-node-image: gitea.app.keskikuja.site/niko/ci-cucumber:latest
-
-  report-summary:
-    name: Report Summary
-    needs: [load-config, bats, cucumber]
-    if: always()
-    uses: niko/gitea-ci-library/.gitea/workflows/report-summary.yml@main
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      suites: bats cucumber
@@ -1,68 +0,0 @@
-name: CI Main
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-jobs:
-  load-config:
-    name: Load example-gitea-env.conf to pipeline env
-    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/example-gitea-env.conf
-
-  check-version:
-    name: Check existing artifact
-    needs: [load-config]
-    uses: niko/gitea-ci-library/.gitea/workflows/check-version.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  bats:
-    name: Bats tests
-    needs: [load-config, check-version]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: niko/gitea-ci-library/.gitea/workflows/example-bats-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      bats-image: gitea.app.keskikuja.site/niko/ci-bats:latest
-
-  cucumber:
-    name: Cucumber tests
-    needs: [load-config, check-version]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: niko/gitea-ci-library/.gitea/workflows/example-cucumber-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      cucumber-node-image: gitea.app.keskikuja.site/niko/ci-cucumber:latest
-
-  build-push:
-    name: Build & Push Docker
-    needs: [load-config, check-version, bats, cucumber]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: niko/gitea-ci-library/.gitea/workflows/docker-build-push.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      version: ${{ needs.check-version.outputs.version }}
-
-  report-summary:
-    name: Report Summary
-    needs: [load-config, build-push]
-    if: always()
-    uses: niko/gitea-ci-library/.gitea/workflows/report-summary.yml@main
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      suites: bats cucumber
-
-  tag-maintenance:
-    name: Move provider version tag
-    needs: [build-push]
-    if: success()
-    uses: niko/gitea-ci-library/.gitea/workflows/tag-maintenance.yml@main
-    secrets: inherit
@@ -1,11 +0,0 @@
-name: Hello World (Manual)
-on:
-  workflow_dispatch:
-  push:
-    # branches: [ main ] # Tai [ feature/ci-container ]
-    branches: [feature/ci-container]
-jobs:
-  greet:
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo "Hello"
@@ -3,4 +3,3 @@ GIT_PAGES_URL=https://ci-reports.helm-dev.keskikuja.site
 DOCKER_REGISTRY=gitea.app.keskikuja.site/niko
 DOCKER_IMAGE_NAME=gitea-ci-library-test-image
 DOCKER_UI_URL=https://gitea.app.keskikuja.site/niko/-/packages/container/gitea-ci-library-test-image
-#DOCKERFILE=Dockerfile.platform
@@ -0,0 +1,173 @@
+name: Quality Gate
+on:
+  workflow_call:
+    inputs:
+      env_json:
+        required: true
+        type: string
+      bats-image:
+        required: true
+        type: string
+      cucumber-node-image:
+        required: true
+        type: string
+    secrets:
+      GITEA_TOKEN:
+        required: true
+      GIT_PAGES_PUBLISH_TOKEN:
+        required: true
+
+env:
+  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
+  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
+  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          repository: niko/gitea-ci-library
+          path: .ci
+
+      - name: Pending
+        run: bash .ci/scripts/report-status.sh pending "Validating CI config..." ci-validate
+
+      - name: Validate CI config
+        id: validate
+        run: bash .ci/scripts/ci-validate.sh
+
+      - name: Report status
+        if: always()
+        run: |
+          if [ "${{ steps.validate.outcome }}" = "success" ]; then
+            bash .ci/scripts/report-status.sh success "CI config valid" ci-validate
+          else
+            bash .ci/scripts/report-status.sh failure "CI validation FAILED" ci-validate
+            exit 1
+          fi
+
+  bats:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          repository: niko/gitea-ci-library
+          path: .ci
+
+      - name: Pending
+        run: bash .ci/scripts/report-status.sh pending "Running Bats tests..." ci-bats
+
+      - name: Run bats tests
+        id: bats-tests
+        shell: bash
+        run: |
+          docker volume create bats-workspace
+          tar c . | docker run --rm -i -v bats-workspace:/data alpine tar x -C /data
+          mkdir -p "reports/${GITHUB_SHA:0:8}/bats"
+          set +e
+          docker run --rm \
+            -v bats-workspace:/data \
+            --entrypoint bash ${{ inputs.bats-image }} \
+            -c 'apk add -q lsof python3 jq curl ruby && cd /data && gem install bashcov -v 3.3.0 2>&1 | tail -1 && bashcov -- bats tests/' \
+            > "reports/${GITHUB_SHA:0:8}/bats/results.txt" 2>&1
+          BATS_EXIT=$?
+          bash .ci/.gitea/scripts/bats-coverage.sh bats-workspace "reports/${GITHUB_SHA:0:8}/bats"
+          docker volume rm bats-workspace > /dev/null 2>&1
+          bash .ci/.gitea/scripts/bats-report.sh "reports/${GITHUB_SHA:0:8}/bats"
+          echo "BATS_EXIT=${BATS_EXIT}" >> "${GITHUB_ENV}"
+          exit ${BATS_EXIT}
+
+      - name: Publish bats reports
+        if: always()
+        run: bash .ci/scripts/publish-git-pages.sh bats
+
+      - name: Report status
+        if: always()
+        run: |
+          if [ "${BATS_EXIT}" = "0" ]; then
+            bash .ci/scripts/report-status.sh success "Bats tests OK" ci-bats bats
+          else
+            bash .ci/scripts/report-status.sh failure "Bats tests FAILED" ci-bats bats
+          fi
+
+  cucumber:
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ inputs.cucumber-node-image }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          repository: niko/gitea-ci-library
+          path: .ci
+
+      - name: Pending
+        run: bash .ci/scripts/report-status.sh pending "Running Cucumber tests..." ci-cucumber
+
+      - name: Run cucumber tests
+        id: cucumber-tests
+        shell: bash
+        run: |
+          apt-get update -qq && apt-get install -y -qq --no-install-recommends lsof jq
+          npm install @cucumber/cucumber > /dev/null 2>&1
+          mkdir -p "reports/${GITHUB_SHA:0:8}/cucumber"
+          set +e
+          npx cucumber-js \
+            --format json:"reports/${GITHUB_SHA:0:8}/cucumber/report.json" \
+            --format html:"reports/${GITHUB_SHA:0:8}/cucumber/index.html" 2>&1
+          CUCUMBER_EXIT=$?
+          echo "CUCUMBER_EXIT=${CUCUMBER_EXIT}" >> "${GITHUB_ENV}"
+          exit ${CUCUMBER_EXIT}
+
+      - name: Publish cucumber reports
+        if: always()
+        run: bash .ci/scripts/publish-git-pages.sh cucumber
+
+      - name: Report status
+        if: always()
+        run: |
+          if [ "${CUCUMBER_EXIT}" = "0" ]; then
+            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
+              bash .ci/scripts/report-status.sh success "Cucumber tests OK" ci-cucumber cucumber
+            else
+              bash .ci/scripts/report-status.sh success "Cucumber tests OK" ci-cucumber
+            fi
+          else
+            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
+              bash .ci/scripts/report-status.sh failure "Cucumber tests FAILED" ci-cucumber cucumber
+            else
+              bash .ci/scripts/report-status.sh failure "Cucumber tests FAILED" ci-cucumber
+            fi
+          fi
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [bats, cucumber]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          repository: niko/gitea-ci-library
+          path: .ci
+
+      - name: Pending
+        run: bash .ci/scripts/report-status.sh pending "Generating report index..." ci-build
+
+      - name: Generate report index
+        id: report-index
+        run: bash .ci/.gitea/scripts/generate-report-index.sh
+
+      - name: Report status
+        if: always()
+        run: |
+          if [ "${{ steps.report-index.outcome }}" = "success" ]; then
+            bash .ci/scripts/report-status.sh success "Build complete" ci-build
+          else
+            bash .ci/scripts/report-status.sh failure "Build FAILED" ci-build
+            exit 1
+          fi
@@ -1,34 +0,0 @@
-name: Report Summary
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-      suites:
-        required: true
-        type: string
-        description: Space-separated suite names published to git-pages
-
-env:
-  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
-
-jobs:
-  summary:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Generate report links
-        shell: bash
-        run: |
-          SHA8="${GITHUB_SHA:0:8}"
-          BASE="${GIT_PAGES_URL}/${GITHUB_REPOSITORY}/reports/${SHA8}"
-
-          {
-            echo "## Test Reports"
-            echo ""
-            echo "| Suite | Report |"
-            echo "|-------|--------|"
-            for suite in ${{ inputs.suites }}; do
-              echo "| ${suite} | [View report](${BASE}/${suite}/) |"
-            done
-          } >> "${GITHUB_STEP_SUMMARY}"
@@ -1,38 +0,0 @@
-name: Tag Maintenance
-on:
-  workflow_call:
-    secrets:
-      GITEA_TOKEN:
-        required: true
-
-jobs:
-  move-tag:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Read current provider version
-        id: version
-        run: echo "TAG=$(cat CURRENT_PROVIDER_VERSION | tr -d '[:space:]')" >> "$GITHUB_OUTPUT"
-
-      - name: Move tag to commit
-        run: |
-          TAG="${{ steps.version.outputs.TAG }}"
-          SHA="${{ github.sha }}"
-
-          curl -sf -X DELETE \
-            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
-            "${{ gitea.server_url }}/api/v1/repos/${{ github.repository }}/tags/${TAG}" || true
-
-          HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
-            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
-            -H "Content-Type: application/json" \
-            "${{ gitea.server_url }}/api/v1/repos/${{ github.repository }}/tags" \
-            -d "{\"tag_name\": \"${TAG}\", \"message\": \"Release ${TAG}\", \"target\": \"${SHA}\"}")
-
-          if [ "$HTTP_CODE" = "201" ]; then
-            echo "${TAG} tag moved to ${SHA}"
-          else
-            echo "ERROR: failed to move ${TAG} tag (HTTP $HTTP_CODE)" >&2
-            exit 1
-          fi
@@ -1 +0,0 @@
-v1
@@ -1,3 +0,0 @@
-FROM bats/bats:latest
-RUN apk add --no-cache lsof python3 jq curl ruby && \
-    gem install bashcov -v 3.3.0
@@ -1,7 +0,0 @@
-FROM node:22
-RUN apt-get update -qq && \
-    apt-get install -y -qq --no-install-recommends lsof jq && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/* && \
-    npm install -g @cucumber/cucumber
-ENV NODE_PATH=/usr/local/lib/node_modules
@@ -2,8 +2,6 @@

 Reusable workflow -kirjasto Gitea Actionsille. Lisätietoja: [docs/](docs/)

-**Consumer-käyttöönotto:** [docs/consumer-guide.md](docs/consumer-guide.md) — vaiheittainen ohje uuden projektin liittämiseen
-
 ## Provider-binding — miten consumer löytää providerin

 Consumer kutsuu provideria `uses:`-viittauksella. Ei discoveryä — polku kovakoodataan consumerin
@@ -6,8 +6,8 @@ Provider-repossa (`gitea-ci-library`) kansioiden omistajuus on seuraava:

 | Kansio / Tiedosto | Omistaja | Tyyppi |
 |-------------------|----------|--------|
-| `.gitea/workflows/` | Sekoitettu | Providerin reusable workflowt + consumerin example-pipeline |
-| `.gitea/workflows/example-gitea-env.conf` | Consumer | KEY=VALUE config |
+| `.gitea/workflows/` | Sekoitettu | Providerin reusable workflowt + consumerin pipeline |
+| `.gitea/workflows/gitea-env.conf` | Consumer | KEY=VALUE config |
 | `.gitea/scripts/` | Consumer | Consumer-skriptit |
 | `scripts/` | Provider | Providerin sisäiset työkalut |

@@ -30,12 +30,12 @@ uses: org/repo/scripts/workflow.yml@branch
 ```

 Tästä syystä providerin reusable workflowt (`config-provider.yml`,
-`check-version.yml`, `docker-build-push.yml`) ovat samassa `.gitea/workflows/`-kansiossa
-consumerin esimerkkipipeline-tiedostojen (`example-*`) kanssa.
+`build-feature.yml`) ovat samassa `.gitea/workflows/`-kansiossa consumerin
+pipeline-tiedostojen (`ci.yml`) kanssa.

 Erottelu on nimessä ja dokumentaatiossa, ei kansiorakenteessa:
- `config-provider.yml`, `check-version.yml`, `docker-build-push.yml` — providerin tarjoamia
- `example-feature.yml`, `example-main.yml`, `example-*.yml` — consumer-esimerkkejä
+- `config-provider.yml`, `build-feature.yml` — providerin tarjoamia
+- `ci.yml` — consumerin omistamia

 ## Providerin `scripts/` (juuressa)

@@ -52,7 +52,7 @@ Consumerin omat skriptit, osana consumerin pipeline-logiikkaa.
 Kutsutaan consumerin workflowista ilman tupla checkouttia:
 `.gitea/scripts/bats-report.sh`.

-## Consumerin `.gitea/workflows/example-gitea-env.conf`
+## Consumerin `.gitea/workflows/gitea-env.conf`

 Consumerin konfiguraatiotiedosto. Providerin `config-provider.yml`
 lukee tämän ja muuntaa JSONiksi, mutta consumer omistaa sisällön.
@@ -61,7 +61,8 @@ lukee tämän ja muuntaa JSONiksi, mutta consumer omistaa sisällön.

 - Provider voi muuttaa `scripts/` ja `config-provider.yml` sisältöä
  ilman consumerin hyväksyntää (versiovaihdon yhteydessä)
- Consumer voi muuttaa `example-*.yml` ja `.gitea/scripts/` sisältöä
+- Consumer voi muuttaa `.gitea/workflows/ci.yml`,
+  `.gitea/workflows/build-feature.yml` ja `.gitea/scripts/` sisältöä
  ilman providerin muutoksia
 - Providerin workflowt käyttävät `.ci/scripts/...` -polkua (tupla checkout)
 - Consumerin workflowt käyttävät `.gitea/scripts/...` -polkua (natiivi checkout)
@@ -1,85 +0,0 @@
-# 7. Statusraportoinnin pattern
-
-## Päätös
-
-Gitea Actionsin natiivi job-status on ensisijainen. Commit-status API:a
-(`report-status.sh`) käytetään **vain** kun työvaihe tuottaa ulkoisen linkin
-(testiraportti, Docker registry), jota natiivistaatus ei tue.
-
-### Tool-jobit (validate, check-version, tag-commit)
-
-Ei API-kutsuja. Luotetaan Gitean omaan job-statukseen.
-
-```yaml
- uses: actions/checkout@v4
-
- name: Do work
-  run: do-something
-```
-
-### Test-jobit (bats, cucumber)
-
-API:a käytetään raporttilinkin upottamiseksi commit-näkymään.
-
-```
-testit → publish (always) → status (always, exit-koodin mukaan)
-```
-
-```yaml
- name: Run tests
-  shell: bash
-  run: |
-    run-tests
-    EXIT=$?
-    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
-    exit ${EXIT}
-
- name: Publish reports
-  if: always()
-  run: bash .ci/scripts/publish-git-pages.sh bats
-
- name: Report status
-  if: always()
-  shell: bash
-  run: |
-    if [ "${EXIT}" = "0" ]; then
-      bash .ci/scripts/report-status.sh success "Link to Bats reports" unit-tests bats
-    else
-      bash .ci/scripts/report-status.sh failure "Link to Bats reports" unit-tests bats
-    fi
-```
-
-### Build & push -jobit (docker-build-push)
-
-API:a käytetään Docker registry -linkin upottamiseksi.
-
-```
-build → push → SUCCESS (registry-linkillä) / FAILURE
-```
-
-## Periaatteet
-
-1. Gitea Actionsin natiivi job-status on ensisijainen — myös PENDING/Running-tila
-   tulee natiivisti. API:a käytetään vain custom-linkin tarpeeseen (ADR 0004).
-2. `run`-komennon on nostettava virhe ylös — oli kyse tool-callista tai
-   testivirheestä (ADR 0008).
-3. Test-jobit käyttävät `if: always()` publish- ja status-stepeissä — raportti
-   julkaistaan ja status asetetaan aina, riippumatta testin lopputuloksesta.
-4. Testiraportit julkaistaan myös virhetilanteessa, mikäli ne ovat syntyneet.
-5. Commit-statuksen duplikaatio natiivijob-statuksen kanssa hyväksytään
-   testijobeille — se on ainoa mekanismi upottaa raporttilinkki commit-näkymään.
-6. Tool-jobit eivät käytä API:a lainkaan — ne luottavat Gitean natiiviin
-   job-statukseen.
-
-## Tausta
-
-Aiemmin commit-status API:a käytettiin jokaisessa työvaiheessa, myös niissä
-joilla ei ollut raporttia linkitettäväksi (validate, check-version, tag-commit).
-Tämä tuotti duplikaatiota: Gitea näytti sekä natiivin `CI Main / Validate CI config
-Successful` että API-statuksen `ci-validate CI config valid`. Kehittäjälle
-molemmat kertoivat saman asian.
-
-Käytännön pakko kuitenkin pakottaa API:n käyttöön testijobeissa: ilman
-raporttilinkkiä kukaan ei löydä testituloksia. Gitean natiivi job-status
-linkittää aina jobin lokiin — ei ulkoiseen raporttiin. Tämä on paras
-saatavilla oleva kompromissi.
@@ -1,73 +0,0 @@
-# 8. Exit code — ainoa onnistumisen mittari
-
-## Päätös
-
-Jokaisen `run`-stepin on nostettava virheellinen exit-koodi ylös sellaisenaan.
-Exit-koodia ei saa "syödä" missään tilanteessa. Onnistumisen ja epäonnistumisen
-päättely tapahtuu **ainoastaan** exit-koodin perusteella — ei tiedostojen
-olemassaolon, stdout-tulosteen tai minkään muun heuristiikan perusteella.
-
-## Periaatteet
-
-1. Exit-koodi on ainoa totuus. `0` = onnistui, kaikki muut = epäonnistui.
-2. Exit-koodia ei saa syödä. Pipe (`|`) viimeisenä komentona `tee`:hen syö
-   exit-koodin — `docker run … | tee file` palauttaa aina 0.
-3. Data transfer -pipet ovat sallittuja (`tar c . | docker run … tar x`),
-   koska niiden exit-koodilla ei ole semanttista merkitystä.
-4. Testien tai työkalujen ajaminen ei saa päättyä pipeen.
-5. `set -o pipefail` ei ole riittävä suojaus — PIPESTATUS resetoituu herkästi.
-
-## Sallitut patternit
-
-```yaml
-# Oikein: suora ajo, exit koodi $?:iin
- name: Do work
-  run: |
-    some-command
-    EXIT=$?
-    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
-    exit ${EXIT}
-
-# Oikein: stdout talteen ilman pipeä
- name: Do work
-  run: |
-    some-command > results.txt 2>&1
-    EXIT=$?
-    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
-    exit ${EXIT}
-
-# Oikein: docker run ilman pipeä
- name: Run in container
-  run: |
-    docker run --rm image command > output.txt 2>&1
-    EXIT=$?
-    exit ${EXIT}
-```
-
-## Kielletyt patternit
-
-```yaml
-# Väärin: pipe syö exit-koodin
- run: docker run … | tee results.txt
-
-# Väärin: pipe syö exit-koodin
- run: tar … | docker … | tee file
-
-# Väärin: onnistumisen päättely tiedoston olemassaolosta
- run: |
-    some-command || true
-    [ -f success.txt ] && exit 0 || exit 1
-```
-
-## Tausta
-
-Gitea Actionsissa `run`-stepin tila määräytyy viimeisen komennon exit-koodista.
-Pipe (`|`) asettaa `$?`:ksi viimeisen komennon tuloksen — jos viimeinen komento
-on `tee`, tulos on aina 0 riippumatta siitä mitä aiemmat komennot palauttivat.
-
-Tämä on aiheuttanut tuotannossa tilanteita, joissa testit feilasivat mutta jobi
-näytti vihreää, koska `tee` söi exit-koodin. Virhe havaittiin vasta kun raportteja
-alettiin lukea manuaalisesti — commit-status valehteli.
-
-Ratkaisu on yksiselitteinen: exit-koodi talteen `$?`-muuttujaan ennen kuin mikään
-muu komento ehtii muuttaa sitä, ja stepin viimeinen komento on aina `exit ${EXIT}`.
@@ -1,53 +0,0 @@
-# 9. Breaking changes kielletty
-
-## Päätös
-
-Providerin `v1`-tagin osoittamaa rajapintaa ei koskaan rikota.
-Consumerin `uses:`-kutsut säilyvät yhteensopivina — uusi versiotagi
-(`v2`, `v3`) luodaan VAIN jos taaksepäin yhteensopimaton muutos on
-pakottava. Käytännössä: `v1` on pysyvä, ja sitä ylläpidetään
-eteenpäin.
-
-## Rajapinnan määritelmä
-
-Providerin rajapinta = `config-provider.yml` ja `check-version.yml`
-workflow_call-inputit ja -outputit:
-
- Inputtien nimet, tyypit ja required-arvot eivät muutu
- Outputtien nimet eivät katoa
- Secret-nimet eivät muutu
- Workflow-tiedoston nimi ja polku eivät muutu
-
-Sisäinen toteutus (scriptit, checkout-logiikka, build-vaiheet) voi
-muuttua vapaasti — consumer ei ole niistä riippuvainen.
-
-## Versiotagin siirto
-
-Tagi `v1` siirretään automaattisesti uusimpaan onnistuneeseen
-main-commitin CI-ajoon (`tag-maintenance.yml`). Tagin nimi luetaan
-tiedostosta `CURRENT_PROVIDER_VERSION`.
-
-Jos breaking change joskus tulee pakottavaksi:
-1. Päivitä `CURRENT_PROVIDER_VERSION` → `v2`
-2. Luo uusi `v2`-tagi manuaalisesti (osoittaa uuteen rajapintaan)
-3. `tag-maintenance.yml` alkaa ylläpitää `v2`:ta eteenpäin
-4. `v1`-tagia **ei poisteta** — se jää osoittamaan viimeistä
-   v1-yhteensopivaa committia. `v1`:tä käyttävät consumerit
-   jatkavat toimintaansa ilman muutoksia.
-5. Uudet consumerit ottavat käyttöön `@v2`:n.
-
-Aktiivisesti ylläpidetään vain yhtä tagia (`CURRENT_PROVIDER_VERSION`).
-Vanhat tagit säilyvät paikoillaan taaksepäin yhteensopivuutta varten.
-
-## Perustelu
-
-Yhden aktiivisen tagin ylläpito on yksinkertaisempaa kuin usean
-rinnakkaisen version aktiivinen hallinta. Homelab-ympäristössä
-consumerit ovat saman ylläpitäjän hallinnassa — eri tiimien
-rinnakkaisia aktiiviversioita ei tarvita.
-
-Breaking changen sattuessa vanha tagi säilyy — vanhat consumerit
-eivät hajoa. Uusi tagi otetaan käyttöön uusissa consumereissa.
-
-Breaking changen kielto pakottaa suunnittelemaan rajapinnat
-huolellisesti etukäteen.
@@ -1,43 +0,0 @@
-# 10. Pipeline-reititin — ei komentoja
-
-## Päätös
-
-CI-pipelinetiedostot (`ci-main.yml`, `ci-feature.yml`) ovat puhtaita
-**reitittimiä**. Ne eivät saa sisältää `run:`-komentoja, inline-skriptejä
-tai varsinaista build-/test-logiikkaa. Niiden ainoa sallittu sisältö on:
-
- `uses:` — viittaus reusable workflow'hun
- `needs:` — riippuvuus toisen jobin valmistumiseen
- `if:` — ehdollinen suoritus
- `secrets: inherit` — salaisuuksien välitys
-
-## Mikä ei kuulu reitittimeen
-
- `run:`-komennot
- Inline-skriptit (shell, Python, tms.)
- `actions/checkout` (paitsi providerin sisäinen infrastruktuuri)
- Build-työkalut, testikomennot, Docker-komennot
- Raporttien generointi
-
-## Missä logiikka on
-
-| Kerros | Tiedosto | Sisältö |
-|---|---|---|
-| Reititin | `ci-main.yml`, `ci-feature.yml` | Vain `uses:`-kutsut |
-| Workflow_call | `ci-unit-tests.yml`, `ci-acc-tests.yml`, … | Varsinainen testi-/build-logiikka |
-| Provider | `config-provider.yml`, `check-version.yml`, … | Jaettu infrastruktuuri |
-| Skriptit | `scripts/` | Apufunktiot (status, publish, validointi) |
-
-## Perustelu
-
-Reitittimen ja toteutuksen erottelu:
-
- Reititin kertoo **mitä** ajetaan ja **missä järjestyksessä** — luettavissa
-  yhdellä silmäyksellä ilman teknistä taustaa
- Toteutus (workflow_call) kertoo **miten** — tekninen henkilö voi keskittyä
-  yhteen tiedostoon kerrallaan
- Providerin reusable workflow't eivät koskaan sisällä inline-logiikkaa —
-  skriptit ovat omissa tiedostoissaan
-
-Tämä on sama periaate kuin web-sovelluksissa: reititin ei sisällä
-business-logiikkaa, vain HTTP-verbit ja polut.
@@ -1,6 +1,6 @@
 # AI Context: Gitea Actions CI -kirjasto

-**Updated**: 2026-06-15 (siivottu, provider/consumer-erottelu valmis)
+**Updated**: 2026-06-12 (POC-vaihe, suunniteltu uudelleenkirjoitus)

 ## Project Overview
 Gitea Actions reusable workflow -kirjasto mikropalveluiden build-, testaus-,
@@ -8,68 +8,90 @@ raportointi-, deployment- ja test flow -prosessien orkestrointiin. Korvaa
 `ci-jenkins-library`:n Gitea-natiivilla toteutuksella. Mikropalvelut
 käyttävät kirjastoa `uses:`-direktiivillä.

+POC on valmis: raporttien julkaisu git-pagesiin ja commit-status linkillä
+toimii.
+
 ## Monorepo: kaksi erillistä kokonaisuutta

+Tämä repo on käytännössä monorepo, jossa on kaksi itsenäistä osaa:
+
 ### 1. Juuri (`gitea-ci-library`)
 Provider-kirjasto: reusable workflowt, scriptit, ADRt, dokumentaatio.
-Consumer kutsuu provider-workflowta `uses:`-direktiivillä.
+Consumer kutsuu `build-feature.yml`-workflowa `uses:`-direktiivillä.

 ### 2. `git-pages/` — oma kokonaisuus
 Helm-chartti Codeberg git-pagesille. Täysin itsenäinen — oma dokumentaatio,
-omat tekniset valinnat, oma design-rationale. Kaikki git-pages-spesifi tieto
-kuuluu `git-pages/docs/`-alle, ei juuren `docs/`-kansioon.
+omat tekniset valinnat, oma design-rationale. Kohdeltava kuten se olisi jo
+oma reponsa: kaikki git-pages-spesifi tieto kuuluu `git-pages/docs/`- alle,
+ei juuren `docs/`-kansioon.
+
+### Rajapinta juuren ja git-pagesin välillä
+
+Ohut ja yksiselitteinen:
+
+```
+scripts/publish-git-pages.sh <report-dir>
+  → PATCH tar osoitteeseen GIT_PAGES_URL
+  → palauttaa BASE URL:n
+
+git-pages tarjoaa:
+  - HTTP endpoint (GET/PATCH/PUT)
+  - retention (automaattinen)
+  - TLS, BasicAuth (Traefik)
+```
+
+Juuri ei tiedä git-pagesin sisäisestä toiminnasta (storage v2, .index,
+blob-arkkitehtuuri). Git-pages ei tiedä workflowista, scripteistä tai
+provider-logiikasta.
+
+## Architecture (POC-tila)
+- **Provider & Consumer -malli**: `build-feature.yml` on lukittu rajapinta.
+  ADR 0005.
+- **Raporttien hostaus**: git-pages Helm-chartilla (`git-pages/`), `GIT_PAGES_URL` määrittää perusosoitteen.
+- **Retention**: sidecar samassa podissa, HTTP API localhost:3000,
+  Gitea API branch-check.
+- **Commit-status**: Gitea Actions näyttää automaattisesti. API vain
+  custom-linkkiin. ADR 0004.
+- **Julkaisu**: `publish-git-pages.sh` → PATCH tar git-pagesiin.

 ## Repository Structure

 | Path | Purpose |
 |---|---|
-| `.gitea/workflows/config-provider.yml` | Provider: lataa + validoi config-tiedoston, tuottaa `env_json` |
-| `.gitea/workflows/check-version.yml` | Provider: tarkistaa onko commitille jo artifact, laskee version |
-| `.gitea/workflows/docker-build-push.yml` | Provider: buildaa + puskea Docker-imagen, tagittaa commitin |
-| `.gitea/workflows/example-*` | **Consumer-esimerkki**: tämän repon oma CI (dogfood) |
-| `scripts/` | Provider-skriptit: `report-status.sh`, `publish-git-pages.sh`, `ci-validate.sh` |
-| `.gitea/scripts/` | **Consumer-skriptit**: `bats-coverage.sh`, `bats-report.sh` |
-| `docs/` | Arkkitehtuuri, ADRt (0004–0008) |
+| `.gitea/workflows/` | Reusable workflowt (`build-feature.yml`, `config-provider.yml`) |
+| `scripts/` | `publish-git-pages.sh`, `report-status.sh`, `dispatch-workflow.sh` |
+| **`git-pages/`** | **Oma kokonaisuus: Helm-chartti + docs + retention** |
+| `docs/` | Root-tason arkkitehtuuri, ADRt (0001–0005) |
 | `docs/adr/` | Architecture Decision Records |
-| `git-pages/` | Raporttien hostaus (Helm-chartti) |
 | `tests/` | Bats-testit skripteille |
+| `.gitea/workflows/ci.yml` | Dogfood — kutsuu `build-feature.yml`:a |

-### Provider workflowt (4 kpl)
-
-| Workflow | Input | Output | Kuvaus |
-|---|---|---|---|
-| `config-provider.yml` | `config_path` | `env_json`, `config_path` | Validoi ja jäsentää `.conf` → JSON. Sama kutsu hoitaa validoinnin. |
-| `check-version.yml` | `env_json` | `artifact_exists`, `version` | Tarkistaa git-tagit ja `package.json`:n, laskee seuraavan version. Vain main-haarassa. |
-| `docker-build-push.yml` | `env_json`, `version` | — | Buildaa Docker-imagen, puskea rekisteriin, tagittaa commitin. |
-| `report-summary.yml` | `env_json`, `suites` | — | Generoi `GITHUB_STEP_SUMMARY`-taulukon raporttilinkeillä (Gitea 1.27+) |
-
-### Example-tiedostot (consumer-referenssi)
-
-| Tiedosto | Laukaisin | Flow |
-|---|---|---|
-| `example-feature.yml` | push [ei main] | load-config → bats + cucumber → report-summary |
-| `example-main.yml` | push [main] | load-config → check-version → bats + cucumber → report-summary → docker-build-push |
-| `example-bats-tests.yml` | workflow_call | Unit-testit Batsilla, raportit git-pagesiin, status linkillä |
-| `example-cucumber-tests.yml` | workflow_call | Hyväksymätestit Cucumberilla, raportit git-pagesiin, status linkillä |
-| `example-gitea-env.conf` | — | KEY=VALUE config tälle repolle |
+**Tarkemmat git-pages-asiat:** `git-pages/docs/` (implementation-notes,
+architecture, design-rationale, secrets, tech-stack).

 ## Key Technical Decisions
-
- **Provider & Consumer -malli**: `example-*`-tiedostot ovat consumer-esimerkkejä, provider-workflowt reusableja. ADR 0005.
- **Vain Gitea, vain reusable workflowt**: ei custom actioneita, ei multi-platform
- **Commit-status API vain raporttilinkeille**: Tool-jobit luottavat natiiviin. Test-jobit käyttävät API:a koska se on ainoa tapa upottaa raporttilinkki. ADR 0004, 0007.
- **Exit-koodi on ainoa onnistumisen mittari**: Ei pipeä, ei tiedostoheuristiikkaa. ADR 0008.
+- **Provider & Consumer**: `build-feature.yml` lukittu rajapinta, muu koodi
+  vapaasti muutettavissa
+- **Vain Gitea, vain reusable workflowt**: ei custom actioneita, ei
+  multi-platform
 - **Raportit git-pagesissa**: HTML selailtavissa, retention automaattinen
- **GITHUB_STEP_SUMMARY**: Summary-näkymä raporttilinkeille Gitea 1.27:ssä (forward-compat)
+- **Git-pages omana kokonaisuutena**: voi erottaa omaksi repokseen
+  tulevaisuudessa
+
+## Tech Stack (POC)
+- **Runtime:** Bash, curl, jq, python3 (retention whiteout)
+- **Alusta:** Gitea Actions, Gitea act runner
+- **Hostaus:** git-pages 0.9.1 (Codeberg), Traefik, cert-manager
+- **Integraatiot:** Gitea REST API, Gitea Packages

 ## Common Commands
 - Helm-asennus: `helm upgrade --install git-pages ./git-pages -n <ns> -f <values>`
 - Julkaisu: `bash scripts/publish-git-pages.sh <report-dir>`
- Status: `bash scripts/report-status.sh <state> <desc> <context> [suite] [url]`
+- Status: `bash scripts/report-status.sh <state> <desc> <url> <context>`

 ## What NOT to Do
 - Älä lisää tukea muille Git-alustoille
 - Älä lisää Docker custom actioneita ilman pakottavaa syytä
- Älä kirjoita git-pages-spesifiä tietoa juuren `docs/`-kansioon
- Älä käytä commit-status API:a jollei ole raporttia linkitettäväksi (ADR 0007)
- Älä käytä pipeä `run`-komennon viimeisenä — se syö exit-koodin (ADR 0008)
+- Älä kirjoita git-pages-spesifiä tietoa juuren `docs/`-kansioon —
+  kuuluu `git-pages/docs/`-alle
+- Älä POSTaa commit-status APIin jokaiselle vaiheelle — natiivi riittää
@@ -1,6 +1,7 @@
 # Architecture — Gitea Actions CI -kirjasto

-> Normatiivinen lähde: ADR 0004, 0005, 0006, 0007, 0008.
+> ⚠️ POC-vaihe. Tämä dokumentti kuvaa suunniteltua arkkitehtuuria.
+> Normatiivinen lähde: ADR 0004, ADR 0005, `docs/design-rationale.md`.

 ---

@@ -17,52 +18,31 @@ Kirjasto on Gitea-spesifi. Raportit hallinnoidaan git-pages Helm-chartilla

 | Rooli | Kuvaus |
 |-------|--------|
-| **Provider** | `gitea-ci-library` — tarjoaa reusable workflowt (`config-provider.yml`, `check-version.yml`, `docker-build-push.yml`) ja scriptit |
-| **Consumer** | Mikropalveluprojekti — kutsuu `uses:`-direktiivillä, omistaa pipeline-logiikan. Tämän repon oma toteutus: `example-*`-tiedostot |
+| **Provider** | `gitea-ci-library` — tarjoaa `build-feature.yml` (lukittu rajapinta) sekä scriptit |
+| **Consumer** | Mikropalveluprojekti — kutsuu `uses:`-direktiivillä, omistaa pipeline-logiikan |

 Tarkemmin: ADR 0005.

-## Komponentit
+## Komponentit (POC)

-| Komponentti | Tyyppi | Kuvaus |
-|---|---|---|
-| `config-provider.yml` | Provider | Lataa + validoi `.conf`-tiedoston, tuottaa `env_json` |
-| `check-version.yml` | Provider | Tarkistaa git-tagit, laskee version, palauttaa `artifact_exists` + `version` |
-| `docker-build-push.yml` | Provider | Buildaa Docker-imagen, puskea rekisteriin, tagittaa commitin |
-| `example-feature.yml` | Consumer | Feature-haaran CI: load-config → bats + cucumber → summary |
-| `example-main.yml` | Consumer | Main-haaran CI: load-config → check-version → bats + cucumber → summary → docker |
-| `example-bats-tests.yml` | Consumer | Unit-testit Batsilla |
-| `example-cucumber-tests.yml` | Consumer | Hyväksymätestit Cucumberilla |
-| `report-summary.yml` | Provider | `GITHUB_STEP_SUMMARY`-taulukko raporttilinkeillä (Gitea 1.27+) |
-| `publish-git-pages.sh` | Provider-skripti | PATCH tar git-pagesiin |
-| `report-status.sh` | Provider-skripti | POSTaa commit-status (vain custom-linkkiin) |
-| `ci-validate.sh` | Provider-skripti | Validoi `.conf`-tiedoston ja tarkistaa secretit |
-| `dispatch-workflow.sh` | Provider-skripti | Dispatchee workflown ja pollaa valmistumista |
-| `git-pages/` | Infra | Helm-chartti raporttien hostaukseen. Oma kokonaisuus |
-
-## Statusraportointi
-
-| Job-tyyppi | Mekanismi | Syy |
-|---|---|---|
-| Tool-jobit | Vain Gitea natiivi job-status | Ei raporttia linkitettäväksi |
-| Test-jobit | Commit-status API linkillä | Ainoa tapa upottaa raporttilinkki commit-näkymään |
-| Docker-build-push | Commit-status API linkillä | Linkki Docker registryyn |
-
-Tarkemmin: ADR 0004, 0007.
+| Komponentti | Tila |
+|-------------|------|
+| `build-feature.yml` | Toimii. Ainoa reusable workflow. |
+| `publish-git-pages.sh` | Toimii. PATCH tar git-pagesiin. |
+| `report-status.sh` | Toimii. POSTaa commit-status (vain custom-linkkiin). |
+| `dispatch-workflow.sh` | Toimii. Dispatchee workflown ja pollaa valmistumista. |
+| `git-pages/` | Helm-chartti raporttien hostaukseen. Oma kokonaisuus, tarkemmin: `git-pages/docs/`. |

 ## Ulkoiset palvelut

 | Palvelu | Rooli |
-|---|---|
-| Gitea REST API | Commit-status (vain custom-linkit), git-tagit |
-| Gitea Packages | Docker-imagen säilytys |
-| git-pages | Raporttien hostaus |
+|---------|-------|
+| **Gitea REST API** | Commit-status, workflow-dispatch, run-pollaus |
+| **Gitea Packages** | Docker-imagen säilytys |
+| **git-pages** | Raporttien hostaus |

 ## Arkkitehtuuriset rajoitteet

- Provider-workflowt ovat reusableja (`workflow_call`), consumer omistaa orkestroinnin
+- `build-feature.yml` on ainoa consumerin kutsuma rajapinta (ADR 0005)
 - Gitea Actionsin natiivi commit-status on ensisijainen (ADR 0004)
- API:a käytetään vain custom-linkkeihin (ADR 0007)
- Exit-koodi on ainoa onnistumisen mittari — ei pipeä (ADR 0008)
 - Raportit ovat julkisia URL:lla (osoite tunnettava)
- Consumer-skriptit `.gitea/scripts/`-alla, provider-skriptit `scripts/`-alla (ADR 0006)
@@ -1,5 +1,4 @@
-  **⚠️ STATUS: OSITTAIN VANHENTUNUT** — Statusraportointi (7) ja exit-koodit (8)
-  on formalisoitu ADR:iin 0007 ja 0008. Loput osiot validioitu POC-ajossa.
+	**⚠️ STATUS: ALERT DRAFT** — Ei ole validoitu. Voi sisältää virheellisiä tai puutteellisia käytäntöjä.


 # CI Pipeline Practices
@@ -1,124 +1,269 @@
-# Konfiguraatiomalli — `gitea-env.conf`
+# Konfiguraatiomalli — `ci-flow-values.yaml`

-> Consumer määrittelee ympäristökohtaiset arvot KEY=VALUE-muotoisessa
-> `.conf`-tiedostossa. Providerin `config-provider.yml` validoi tiedoston
-> ja muuntaa sen JSON:ksi (`env_json`), jota kaikki downstream-workflowt
-> käyttävät.
+> ⚠️ **POC-vaihe.** Tämä dokumentti on peritty Jenkins-versiosta ja sisältää
+> Docker-spesifistä legacyä (isContainerBuild, Docker-labelit). POC osoitti,
+> että provider on agnostinen consumerin build-ekosysteemille.
+>
+> Uusi ajattelu: `isContainerBuild()` → `isArtifactBuild()`. Provider ei
+> tiedä eikä tarvitse tietää, buildaako consumer kontin, JARin, npm-paketin
+> vai mitään muuta. Dokumentti odottaa uudelleenkirjoitusta.
+>
+> Normatiivinen lähde: `docs/design-rationale.md`, ADR 0005.

 ---

-## Tiedoston sijainti ja nimi
+## Miksi redesign

-Consumerin repossa: `.gitea/workflows/gitea-env.conf` (nimi vapaasti
-valittavissa — `config-provider.yml`:n `config_path`-input määrittää polun).
+Jenkins-version `ci-flow-values.yaml` oli rakennettu Jenkinsin ympäristömuuttuja- ja credential-mallin ympärille. Gitea Actionsissa konfiguraatio luetaan suoraan YAML:sta workflow'n sisällä — ei tarvita env-muuttujien kautta kierrättämistä. Lisäksi:

-Esimerkki (tämän repon dogfood):
-```
-.gitea/workflows/example-gitea-env.conf
-```
+- `creditentials`-viittaukset korvautuvat Gitea org secrets/variables -mekanismilla
+- `test-flow`-syntaksi yksinkertaistuu (ei enää JSON-serialisointia env-muuttujiin)
+- Docker/NPM-rekisterit MVP:ssä vain Gitea Packages — factory/adapter-pattern valmiina laajennukselle
+- `sonarqube`-konfiguraatio pysyy samankaltaisena
+
+---

 ## Skeema

-```
-KEY=VALUE
-```
-
-Yksi `KEY=VALUE` per rivi. Kommentit `#`-merkillä. Tyhjät rivit ohitetaan.
-
-### Pakolliset avaimet
-
-| Avain | Kuvaus | Esimerkki |
-|---|---|---|
-| `GITEA_API_URL` | Gitea-instanssin URL | `https://gitea.example.com` |
-| `GIT_PAGES_URL` | Raporttihostauksen URL | `https://reports.example.com` |
-
-### Docker-spesifit avaimet (vain jos käytetään `docker-build-push.yml`)
-
-| Avain | Pakollinen | Kuvaus |
-|---|---|---|
-| `DOCKER_REGISTRY` | Kyllä | Rekisterin host/path, esim. `gitea.example.com/org` |
-| `DOCKER_IMAGE_NAME` | Kyllä | Kontin nimi ilman registry-prefixiä |
-| `DOCKER_UI_URL` | Ei | Linkki kontin UI-näkymään registryssä |
-| `DOCKERFILE` | Ei | Dockerfile-nimi, oletus `Dockerfile` |
-
-### Esimerkki
-
-```ini
-GITEA_API_URL=https://gitea.example.com
-GIT_PAGES_URL=https://reports.example.com
-DOCKER_REGISTRY=gitea.example.com/myorg
-DOCKER_IMAGE_NAME=temperature-store
-DOCKER_UI_URL=https://gitea.example.com/myorg/-/packages/container/temperature-store
-#DOCKERFILE=Dockerfile.platform
-```
-
---
-
-## Salaisuudet
-
-Salaisuudet eivät ole `.conf`-tiedostossa. Ne määritellään Gitean
-organization/repository secrets -mekanismissa ja välitetään workflowlle
-`secrets: inherit` -direktiivillä.
-
-| Secret | Pakollinen | Käyttäjä |
-|---|---|---|
-| `GITEA_TOKEN` | Kyllä | `report-status.sh`, `check-version.yml`, `docker-build-push.yml` |
-| `GIT_PAGES_PUBLISH_TOKEN` | Kyllä | `publish-git-pages.sh`, `config-provider.yml` (validointi) |
-| `DOCKER_USERNAME` | Ei | `docker-build-push.yml` (oletus: `github.actor`, ei pakollinen kaikissa registryissä) |
-| `DOCKER_PASSWORD` | Kyllä | `docker-build-push.yml` |
-
---
-
-## `config-provider.yml` — lataus ja validointi
-
-Provider-workflow joka lukee `.conf`-tiedoston, validoi sen ja palauttaa
-JSON-muotoisen `env_json`:n.
-
-**Input:** `config_path` (polku `.conf`-tiedostoon)
-
-**Output:** `env_json` (JSON-string), `config_path` (sama polku takaisin)
-
-**Validointi:**
- `.conf`-tiedosto on olemassa
- Jokaisella `KEY=VALUE`-rivillä on arvo (ei tyhjää)
- URL-tyyppiset avaimet alkavat `http://` tai `https://`
- Pakolliset secretit (`GITEA_TOKEN`, `GIT_PAGES_PUBLISH_TOKEN`) on asetettu
-
-Kutsu:
 ```yaml
-load-config:
-    uses: org/gitea-ci-library/.gitea/workflows/config-provider.yml@v1
+# ci-flow-values.yaml — projektin juuressa
+#
+# Pakolliset osiot: docker (jos master-branch buildaa kontin), test-flow (jos ketjutetaan)
+# Vapaaehtoiset: sonarqube, deployment
+
+docker:
+  registry: gitea                    # gitea | artifactory | nexus (MVP: vain gitea)
+  imageName: temperature-store       # kontin nimi, pakollinen
+
+sonarqube:
+  url: https://sonar.example.com
+  projectKey: temperature-store
+
+deployment:
+  jobName: deploy                    # deploy-workflown nimi (vakio)
+  projectFolder: microservices       # polku Helm-repossa
+  fileName: values-{.environment}.yaml
+  property: container.version
+
+test-flow:
+  - deploy: development              # 1. deploy development-ympäristöön
+    wait: true                       # odota deployn valmistumista
+
+  - test:
+      name: "integration fast"
+      environment: integration
+      repo: tests/integration        # testi-repo (owner/repo)
+      workflow: test.yml             # workflow-tiedosto testi-repossa
+      ref: main                      # branch
+      tags: "@temperature and not @slow"
+
+  - deploy: staging
+    wait: true
+
+  - test:
+      name: e2e
+      environment: staging
+      repo: tests/e2e
+      workflow: test.yml
+      ref: main
+      tags: "@e2e and not @slow"
+```
+
+### Kenttäkuvaukset
+
+#### `docker`
+
+| Kenttä | Pakollinen | Kuvaus |
+|--------|------------|--------|
+| `registry` | Ei (oletus `gitea`) | Rekisterityyppi. MVP: `gitea`. Factory/adapter-pattern avaa `artifactory`, `nexus` myöhemmin |
+| `imageName` | Kyllä | Kontin nimi. Lopullinen tagi: `{gitea_host}/{owner}/{imageName}:{version}.{run_number}` |
+
+#### `sonarqube`
+
+| Kenttä | Pakollinen | Kuvaus |
+|--------|------------|--------|
+| `url` | Kyllä | SonarQube-palvelimen URL |
+| `projectKey` | Kyllä | SonarQube-projektin avain |
+
+SonarQube-token tulee Gitea org secretsista (`SONAR_TOKEN`). Ei `creditentials`-viittausta.
+
+#### `deployment`
+
+| Kenttä | Pakollinen | Kuvaus |
+|--------|------------|--------|
+| `jobName` | Ei (oletus `deploy`) | Deploy-workflown tiedostonimi ilman `.yml`-päätettä |
+| `projectFolder` | Kyllä | Polku mikropalvelun kansioon Helm-repossa |
+| `fileName` | Kyllä | YAML-tiedoston nimi. `{.environment}` korvataan ympäristön nimellä |
+| `property` | Kyllä | Päivitettävä avain (piste-eroteltu polku, esim. `container.version`) |
+
+Deploy-token (kirjoitusoikeus Helm-repoon) tulee Gitea org secretsista (`DEPLOY_TOKEN`).
+
+#### `test-flow`
+
+Array testi-steppejä. Jokainen steppi on joko `deploy` tai `test`.
+
+**`deploy`-steppi:**
+
+| Kenttä | Pakollinen | Kuvaus |
+|--------|------------|--------|
+| `deploy` | Kyllä | Ympäristön nimi (esim. `development`, `staging`) |
+| `wait` | Ei (oletus `true`) | Odotetaanko deployn valmistumista ennen seuraavaa steppiä |
+
+**`test`-steppi:**
+
+| Kenttä | Pakollinen | Kuvaus |
+|--------|------------|--------|
+| `name` | Kyllä | Testivaiheen nimi (näkyy statusviestissä) |
+| `environment` | Kyllä | Ympäristö jota vasten testataan |
+| `repo` | Kyllä | Testi-repo muodossa `owner/repo` |
+| `workflow` | Kyllä | Workflow-tiedosto testi-repossa |
+| `ref` | Kyllä | Branch (esim. `main`) |
+| `tags` | Ei | Cucumber-tagit (esim. `"@smoke and not @slow"`) |
+| `versionApiUrl` | Ei | URL deployed-version tarkistukseen |
+| `versionCheckScript` | Ei | Polku version check -skriptiin (repossa tai kontissa) |
+
+---
+
+## `isArtifactBuild()`-mekanismi (POC: suunniteltu, ei toteutettu)
+
+> **Jenkins-legacy:** Jenkins-versiossa tämä oli `isContainerBuild()`. POC
+> osoitti, että provider ei tiedä eikä tarvitse tietää, buildaako consumer
+> kontin, JARin vai npm-paketin. Siksi `isContainerBuild()` →
+> `isArtifactBuild()`.
+
+**Ongelma:** Samaa committia vasten voidaan ajaa master-workflow useita
+kertoja. On mieletöntä buildata artifakti uudestaan, koska commit on jo
+tagätty versiolla ja artifakti on olemassa rekisterissä. Uudelleenbuildaus
+aiheuttaa versiokonflikteja ja tuhlaa CI-aikaa.
+
+**Ratkaisu:** Workflow'n alussa tarkistetaan, onko tälle commitille jo
+olemassa versiotagi.
+
+```bash
+# is-container-built.sh
+TAG=$(git tag --points-at HEAD | grep -E '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$' | head -1)
+if [ -n "$TAG" ]; then
+  echo "container_already_built=true" >> $GITHUB_ENV
+  echo "container_version=$TAG" >> $GITHUB_ENV
+else
+  echo "container_already_built=false" >> $GITHUB_ENV
+fi
+```
+
+Workflow käyttää tätä ehtona:
+
+```yaml
+jobs:
+  build-container:
+    if: env.container_already_built != 'true'
+    steps:
+      - run: docker build ...
+  test-flow:
+    if: always()
+    needs: [build-container]
+    steps:
+      - run: dispatch-workflow.sh ...
+```
+
+**Mitä `isContainerBuild() == true` tarkoittaa käytännössä:**
+- Kontti on jo buildattu ja pushattu rekisteriin
+- Commit on tagätty versiolla (esim. `1.2.3.42`)
+- Build-steppi skipataan → siirrytään suoraan test flow'hun
+- Sama versio deployataan ja testataan — ei uutta konttia
+
+**Miksi tämä on välttämätöntä:**
+- Estää versiokonfliktit: `1.2.3.42` ei voi olla kahdesti
+- Säästää CI-aikaa: artifaktin buildaus on hitain vaihe
+- Pitää commitin ja artifaktin välisen suhteen yksiselitteisenä: `git tag` kertoo suoraan mikä versio vastaa tätä committia
+
+---
+
+## Version check (Fibonacci-backoff)
+
+Ennen kuin testit ajetaan, pitää varmistua että haluttu konttiversio on oikeasti deployattu ympäristöön. Muuten testataan väärää versiota.
+
+**Malli:** Skripti, joka pollaa deployatun version API:a Fibonacci-backoffilla:
+
+```bash
+#!/bin/bash
+# check-version.sh <version_api_url> <expected_version>
+# Palauttaa 0 jos versiot täsmäävät, 1 muuten.
+
+URL=$1
+EXPECTED=$2
+MAX_RETRIES=10
+
+# Fibonacci-sekvenssi: 1 2 3 5 8 13 21 34 55 89
+FIB=(1 2 3 5 8 13 21 34 55 89)
+
+for i in $(seq 1 $MAX_RETRIES); do
+  ACTUAL=$(curl -s "$URL" | jq -r '.version // empty')
+  if [ "$ACTUAL" = "$EXPECTED" ]; then
+    echo "Version match: $ACTUAL"
+    exit 0
+  fi
+  echo "Attempt $i/$MAX_RETRIES: $ACTUAL != $EXPECTED, waiting ${FIB[$i-1]}s..."
+  sleep ${FIB[$i-1]}
+done
+
+echo "Version mismatch after $MAX_RETRIES attempts"
+exit 1
+```
+
+**Miksi Fibonacci:** Uusi deploy käynnistyy nopeasti (ensimmäiset pollaukset tiheään). Jos kontin pullaus tai podin käynnistys kestää, pollausväli kasvaa — ei turhaan kuormiteta API:a. Maksimiaika: ~231 sekuntia (summa 1..89).
+
+Version check -skripti joko:
+- Asuu testi-repossa (projektin oma toteutus) → `versionCheckScript`-kenttä
+- Tai käyttää geneeristä API:a → `versionApiUrl`-kenttä, skripti on osa kirjastoa
+
+---
+
+## `doNotDowngrade`
+
+Jenkinsin deploy-jobissa oli `doNotDowngrade`-parametri, joka esti vanhemman version deployaamisen uudemman päälle. Gitea Actions -versiossa:
+
+- **Ei MVP:ssä.** Deploy tekee sen mitä käsketään. `doNotDowngrade` on lisäturva, joka voidaan lisätä deploy-workflow'hun myöhemmin.
+- **Mekanismi:** Ennen YAML:n muokkausta tarkistetaan nykyinen versio. Jos `new < current`, skipataan ja raportoidaan.
+- **Toteutus:** Yksi `if`-ehto deploy-workflow'n alussa, ei vaadi muutoksia muualle.
+
+---
+
+## UX-esimerkki: projektin `.gitea/workflows/ci.yml`
+
+Näin mikropalvelun kehittäjä käyttää kirjastoa:
+
+```yaml
+# .gitea/workflows/ci.yml — projektin juuressa
+
+name: CI
+
+on:
+  push:
+    branches: ["**"]
+  workflow_dispatch:
+
+jobs:
+  feature:
+    if: github.ref != 'refs/heads/master'
+    uses: org/gitea-ci-library/.gitea/workflows/ci-feature.yml@v1
    secrets: inherit
    with:
-      config_path: .gitea/workflows/gitea-env.conf
+      config-file: ci-flow-values.yaml
+      maven-image: maven:3.9-eclipse-temurin-21
+
+  master:
+    if: github.ref == 'refs/heads/master'
+    uses: org/gitea-ci-library/.gitea/workflows/ci-master.yml@v1
+    secrets: inherit
+    with:
+      config-file: ci-flow-values.yaml
+      maven-image: maven:3.9-eclipse-temurin-21
+      docker-image: docker:26-dind
 ```

---
+Kehittäjä määrittelee:
+- Millä kontilla buildataan (`maven-image` — koska kirjasto ei tiedä projektin Java-versiota)
+- Mistä konfiguraatio luetaan (`config-file`)
+- Millä docker-versiolla kontit rakennetaan (`docker-image`)

-## `check-version.yml` — version päättely
-
-Provider-workflow joka etsii version prioriteettijärjestyksessä:
-
-1. `VERSION`-tiedosto (plain text, esim. `0.2`)
-2. `package.json` → `.version`-kenttä (Node.js)
-3. `pom.xml` → `<version>`-elementti (Maven)
-
-Hakee git-tagit Gitea API:sta ja laskee seuraavan vapaan patch-version.
-
-**Output:** `artifact_exists` (true/false), `version` (string)
-
-**Idempotentti:** Jos commitilla on jo versiotagi, `artifact_exists=true` ja
-build-vaiheet skipataan. Samaa committia ei buildata kahdesti.
-
---
-
-## `env_json`-propagointi
-
-```
-gitea-env.conf  →  config-provider.yml  →  env_json (JSON-string)
-                                              ↓
-                        ci.yml with: env_json  →  kaikki downstream-workflowt
-```
-
-Jokainen provider-workflow purkaa tarvitsemansa arvot `fromJson(inputs.env_json).KEY`:lla.
-Consumerin ei tarvitse tietää mitä avaimia kukin provider käyttää.
+Kaikki Git-, raportointi-, SonarQube- ja deploy-konfiguraatio on `ci-flow-values.yaml`:ssa.
@@ -1,446 +0,0 @@
-# Consumer Guide — Kirjaston käyttöönotto
-
-> Anna tämä dokumentti AI:lle kun haluat ottaa `gitea-ci-library`:n käyttöön
-> uudessa projektissa tai muokata olemassa olevia pipelineja.
-
---
-
-## Rakenneperiaate
-
-**Pipeline-tiedostot (`ci-feature.yml`, `ci-main.yml`) eivät saa sisältää
-varsinaista logiikkaa.** Ne ovat puhtaita reitittimiä: pelkkiä `uses:`-kutsuja
-`if`- ja `needs`-ehdoilla. Kaikki testien ajaminen, buildaus ja raportointi
-kuuluu omiin `workflow_call`-tiedostoihinsa.
-
-```
-ci-unit-tests.yml     ← testien ajaminen (varsinainen logiikka)
-ci-acc-tests.yml      ← hyväksymätestit (varsinainen logiikka)
-ci-feature.yml        ← reititin: load-config → test-workflow't → summary
-ci-main.yml           ← reititin: load-config → check-version → testit → build → summary
-```
-
-Provider tarjoaa 3 reusable workflow'ta ja joukon skriptejä.
-Consumer omistaa orkestroinnin: mitä palikoita käytetään, missä järjestyksessä,
-millä branch-ehdoilla. Consumer ei kopioi providerin koodia — se viittaa
-`uses:`-direktiivillä.
-
---
-
-## Vaihe 1: Konfiguraatiotiedosto
-
-Luo `.gitea/workflows/gitea-env.conf`:
-
-```ini
-GITEA_API_URL=https://gitea.example.com
-GIT_PAGES_URL=https://reports.example.com
-```
-
-Jos buildaat Docker-kontteja, lisää:
-
-```ini
-DOCKER_REGISTRY=gitea.example.com/myorg
-DOCKER_IMAGE_NAME=my-service
-DOCKER_UI_URL=https://gitea.example.com/myorg/-/packages/container/my-service
-#DOCKERFILE=Dockerfile.platform   # valinnainen, oletus Dockerfile
-```
-
-Salaisuudet määritellään Gitean Settings → Secrets -näkymässä:
-
-| Secret | Pakollinen |
-|---|---|
-| `GITEA_TOKEN` | Aina |
-| `GIT_PAGES_PUBLISH_TOKEN` | Aina |
-| `DOCKER_USERNAME` | Vain jos buildaat kontteja (ei pakollinen kaikissa registryissä) |
-| `DOCKER_PASSWORD` | Vain jos buildaat kontteja |
-
---
-
-## Vaihe 2: Test-workflow't (varsinainen logiikka)
-
-Jokainen testityyppi omaan `workflow_call`-tiedostoonsa. Tässä esimerkki
-Maven-yksikkötesteistä. Luo `.gitea/workflows/ci-unit-tests.yml`:
-
-```yaml
-name: Unit Tests
-on:
-  workflow_call:
-    inputs:
-      env_json:
-        required: true
-        type: string
-    secrets:
-      GITEA_TOKEN:
-        required: true
-      GIT_PAGES_PUBLISH_TOKEN:
-        required: true
-
-env:
-  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
-  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
-  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    container: maven:3.9-eclipse-temurin-21
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/checkout@v4
-        with:
-          repository: org/gitea-ci-library
-          path: .ci
-
-      - name: Run tests
-        shell: bash
-        run: |
-          mvn test
-          EXIT=$?
-          echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
-          exit ${EXIT}
-
-      - name: Publish reports
-        if: always()
-        run: bash .ci/scripts/publish-git-pages.sh junit
-
-      - name: Report status
-        if: always()
-        shell: bash
-        run: |
-          if [ "${EXIT}" = "0" ]; then
-            bash .ci/scripts/report-status.sh success "Link to JUnit reports" unit-tests junit
-          else
-            bash .ci/scripts/report-status.sh failure "Link to JUnit reports" unit-tests junit
-          fi
-```
-
-Hyväksymätesteille vastaava tiedosto `ci-acc-tests.yml` (Cucumber, Playwright
-tms.), jossa oma `container:`, oma testikomento ja oma `suite`-nimi.
-
-**Tärkeää:** `mvn test` korvataan omalla testikomennolla. `container:` ja
-`publish-git-pages.sh`-suite ovat projektikohtaisia. Muu runko pysyy samana.
-
---
-
-## Vaihe 3: Feature-haaran CI (puhdas reititin)
-
-Luo `.gitea/workflows/ci-feature.yml`. **Ei sisällä yhtään `run:`-steppiä**
-— pelkkiä `uses:`-kutsuja:
-
-```yaml
-name: CI Feature
-on:
-  push:
-    branches-ignore:
-      - main
-  workflow_dispatch:
-
-jobs:
-  load-config:
-    uses: org/gitea-ci-library/.gitea/workflows/config-provider.yml@v1
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/gitea-env.conf
-
-  unit-tests:
-    needs: [load-config]
-    uses: ./.gitea/workflows/ci-unit-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  acc-tests:
-    needs: [load-config]
-    uses: ./.gitea/workflows/ci-acc-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  report-summary:
-    needs: [load-config, unit-tests, acc-tests]
-    if: always()
-    uses: org/gitea-ci-library/.gitea/workflows/report-summary.yml@v1
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      suites: junit cucumber
-```
-
---
-
-## Vaihe 4: Main-haaran CI (puhdas reititin)
-
-Luo `.gitea/workflows/ci-main.yml`. **Ei sisällä yhtään `run:`-steppiä**:
-
-```yaml
-name: CI Main
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-jobs:
-  load-config:
-    uses: org/gitea-ci-library/.gitea/workflows/config-provider.yml@v1
-    secrets: inherit
-    with:
-      config_path: .gitea/workflows/gitea-env.conf
-
-  check-version:
-    needs: [load-config]
-    uses: org/gitea-ci-library/.gitea/workflows/check-version.yml@v1
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  unit-tests:
-    needs: [load-config, check-version]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: ./.gitea/workflows/ci-unit-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  acc-tests:
-    needs: [load-config, check-version]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: ./.gitea/workflows/ci-acc-tests.yml@main
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-
-  build-push:
-    needs: [load-config, check-version, unit-tests, acc-tests]
-    if: needs.check-version.outputs.artifact_exists != 'true'
-    uses: org/gitea-ci-library/.gitea/workflows/docker-build-push.yml@v1
-    secrets: inherit
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      version: ${{ needs.check-version.outputs.version }}
-
-  report-summary:
-    needs: [load-config, unit-tests, acc-tests]
-    if: always()
-    uses: org/gitea-ci-library/.gitea/workflows/report-summary.yml@v1
-    with:
-      env_json: ${{ needs.load-config.outputs.env_json }}
-      suites: junit cucumber
-```
-
-Mihin kiinnittää huomiota:
- `check-version` on **idempotentti** — jos commitilla on jo tagi, kaikki
-  sen jälkeiset jobit skipataan (`if: artifact_exists != 'true'`)
- `needs`-ketju takaa järjestyksen ja virheiden propagointin
- Artifakti voi olla **mitä tahansa** — `docker-build-push.yml` on yksi
-  esimerkki. Voit korvata sen Maven-deploylla, npm-publishilla, tai millä
-  tahansa omalla build-workflow'lla. Rajapinta on `version`-input.
-
---
-
-## Versionhallinta
-
-`check-version.yml` lukee version automaattisesti prioriteettijärjestyksessä:
-
-| # | Lähde | Formaatti | Esimerkki |
-|---|---|---|---|
-| 1 | `VERSION`-tiedosto | Plain text | `0.2` |
-| 2 | `package.json` | `.version` | `"version": "0.2.0"` |
-| 3 | `pom.xml` | `<version>` | `<version>0.2.0</version>` |
-
-`major.minor` otetaan tästä. Patch (kolmas numero) lasketaan automaattisesti
-git-tageista. Esim. jos `VERSION` on `0.2` ja tagit ovat `0.2.0`, `0.2.1`,
-niin seuraava on `0.2.2`.
-
---
-
-## Testien lisääminen — oma työkalu
-
-Kopioi `ci-unit-tests.yml`:n rakenne uudelle testityypille ja muuta:
- `container:` — oma testikonttisi
- Testikomento — oma testityökalusi (`npm test`, `pytest`, `go test`, ...)
- `publish-git-pages.sh <suite>` — oma suite-nimi
- `report-status.sh ... <context> <suite>` — oma uniikki konteksti
-
-Lisää uusi jobi reititintiedostoihin (`ci-feature.yml`, `ci-main.yml`)
-samalla `uses:`-kaavalla.
-
-Testijobit ajetaan rinnakkain — ne kaikki `needs: [load-config]` ilman
-keskinäisiä riippuvuuksia.
-
-### Tärkeimmät säännöt
-
-1. **Exit-koodi aina ylös:**
-   ```bash
-   run-tests
-   EXIT=$?
-   echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
-   exit ${EXIT}
-   ```
-
-2. **Ei pipeä testikomennon perään.** `command | tee file` syö exit-koodin.
-   Käytä `command > file 2>&1` jos haluat logit talteen.
-
-3. **Status vain jos on raportti.** Testijobit käyttävät commit-status API:a
-   raporttilinkin takia. Tool-jobit luottavat Gitean natiiviin job-statukseen.
-
-4. **`if: always()`** publish- ja status-stepeissä — raportti julkaistaan
-   ja status asetetaan vaikka testit feilaisivat.
-
-### Raporttien generointi
-
-`publish-git-pages.sh <suite>` odottaa hakemiston `reports/${SHA8}/<suite>/`
-olevan olemassa. Sen sisältö sellaisenaan julkaistaan git-pagesiin.
-`report-status.sh` linkittää statuksen suoraan tähän hakemistoon — selain
-avaa sieltä `index.html`:n.
-
-Test-workflow'n vastuulla on tuottaa raportit oikeaan polkuun. Kaksi
-tyypillistä patternia:
-
-**Pattern 1: Yksi raporttitiedosto (Cucumber)**
-
-Testityökalu tuottaa suoraan HTML-raportin. Yksinkertaisin tapaus:
-
-```bash
-mkdir -p "reports/${GITHUB_SHA:0:8}/cucumber"
-npx cucumber-js \
-  --format html:"reports/${GITHUB_SHA:0:8}/cucumber/index.html"
-```
-
-**Pattern 2: Monta raporttitiedostoa (Bats + coverage)**
-
-Eri työkalut tuottavat eri tiedostoja. Generoi `index.html` joka linkittää
-ne yhteen:
-
-```
-reports/${SHA8}/bats/
-  ├── index.html          ← generoitu: linkit alla oleviin
-  ├── results.txt         ← bats-testien stdout
-  ├── coverage/           ← bashcov-coverage HTML
-  │   └── index.html
-  └── ...
-```
-
-```bash
-mkdir -p "reports/${GITHUB_SHA:0:8}/bats"
-
-# Aja testit → results.txt
-bats tests/ > "reports/${GITHUB_SHA:0:8}/bats/results.txt" 2>&1
-
-# Generoi coverage → coverage-hakemisto
-bashcov -- bats tests/
-
-# Generoi index.html joka linkittää kaikkiin raportteihin
-cat > "reports/${GITHUB_SHA:0:8}/bats/index.html" <<'EOF'
-<!DOCTYPE html>
-<html><body>
-<h1>Bats Test Reports</h1>
-<ul>
-  <li><a href="results.txt">Test results (raw)</a></li>
-  <li><a href="coverage/index.html">Code coverage</a></li>
-</ul>
-</body></html>
-EOF
-```
-
-Yhteistä molemmille: `publish-git-pages.sh <suite>`-kutsun jälkeen raportit
-ovat julkisesti selailtavissa. `report-status.sh`-kutsu `suite`-parametrilla
-linkittää commit-statuksen suoraan `index.html`:ään.
-
-Jos testit feilasivat, raportti generoidaan silti — se kertoo MITKÄ testit
-feilasivat. Siksi publish- ja status-stepit käyttävät `if: always()`.
-
---
-
-## Branch protection (PR-gate)
-
-Gitean Settings → Branches → Add Rule:
-
- **Branch:** `main`
- **Enable Require Status Checks:** päälle
- **Status checks:** valitse `unit-tests`, `acc-tests`
-
---
-
-## Raporttien koonti (Gitea 1.27+)
-
-Kun Gitea päivittyy versioon 1.27, `GITHUB_STEP_SUMMARY`-tuki mahdollistaa
-raporttilinkkien koontinäkymän suoraan Gitea UI:ssa. `report-summary`-jobi
-on mukana molemmissa reititinesimerkeissä yllä — forward-compatibeli, ei
-hajota vanhemmilla versioilla.
-
---
-
-## Provider-rajapinnat — referenssi
-
-### Workflowt
-
-| Workflow | Käyttötarkoitus |
-|---|---|
-| `config-provider.yml` | Lataa + validoi `.conf`, tuottaa `env_json` |
-| `check-version.yml` | Tarkistaa onko commit buildattu, laskee version |
-| `docker-build-push.yml` | Buildaa + puskea Docker-imagen, tagittaa |
-| `report-summary.yml` | `GITHUB_STEP_SUMMARY`-taulukko raporttilinkeillä |
-
-### Skriptit (kutsutaan `.ci/scripts/`-polun kautta)
-
-| Skripti | Käyttötarkoitus |
-|---|---|
-| `report-status.sh` | POSTaa commit-statuksen linkillä |
-| `publish-git-pages.sh` | Julkaisee raporttihakemiston git-pagesiin |
-| `ci-validate.sh` | Validoi `.conf`-tiedoston (kutsutaan `config-provider.yml`:stä) |
-
---
-
-## ADR-yhteenveto — consumerin kannalta oleelliset säännöt
-
-Nämä säännöt on formalisoitu [docs/adr/](docs/adr/)-hakemistossa. Tässä tiivistelmä
-consumer-näkökulmasta:
-
-### Reititin ei sisällä suorittavaa koodia (ADR 0010)
-
-`ci-feature.yml` ja `ci-main.yml` ovat **puhtaita reitittimiä**:
- **Vain** `uses:`, `needs:` ja `if:` sallittu
- **Ei** `run:`-komentoja, ei inline-skriptejä, ei `actions/checkout`
-
-Kaikki suorittava koodi on omissa `workflow_call`-tiedostoissaan:
- `ci-unit-tests.yml` — testikomento, publish, status
- `ci-acc-tests.yml` — testikomento, publish, status
- Provider-workflowt (`config-provider.yml`, `check-version.yml`, …)
-
-### Yksi steppi = yksi workflow_call-tiedosto
-
-Jokainen pipeline-steppi (testityyppi, build, deploy) on oma tiedostonsa.
-Ei kahta eri komentoa samassa workflow'ssa. Tämä pitää reitittimet ohuina
-ja steppitiedostot itsenäisinä — testattavissa erikseen.
-
-### Provider-versio on `@v1` (ADR 0009)
-
-Kaikki `org/gitea-ci-library/…`-viittaukset käyttävät `@v1`-tagia:
-```yaml
-uses: org/gitea-ci-library/.gitea/workflows/config-provider.yml@v1
-```
-`@main` on vain providerin oman repon sisäiseen dogfood-käyttöön.
-
-Breaking changet on kielletty — `v1`-rajapinta on pysyvä.
-
-### Exit-koodi on ainoa onnistumisen mittari (ADR 0008)
-
-Älä käytä pipeä (`|`) komennon perässä — se syö exit-koodin.
-Käytä redirectiä (`> file 2>&1`) jos haluat logit talteen.
-
-### Commit-status vain raporttilinkille (ADR 0007)
-
-`report-status.sh`-skriptiä käytetään VAIN kun on raportti linkitettäväksi.
-Tool-jobit (build, deploy) luottavat Gitean natiiviin job-statukseen.
-
-### Providerin checkout ei kuulu consumerille
-
-Providerin scriptit haetaan `actions/checkout`-stepillä. Consumer käyttää
-providerin määrittelemää polkua (`.ci/scripts/`). Consumer ei kopioi eikä
-muokkaa providerin tiedostoja.
-
-### Testattavuus
-
-Jokainen `workflow_call`-tiedosto on testattavissa itsenäisesti — consumer
-voi ajaa `ci-unit-tests.yml`:n paikallisesti act:lla tai Gitean
-`workflow_dispatch`:llä ilman koko pipelineä.
@@ -1,195 +1,150 @@
 # Design Rationale — Gitea Actions CI -kirjasto

-> Miksi kirjasto on rakennettu näin. Arvot, periaatteet ja reunaehdot, joiden
-> varaan arkkitehtuuri nojaa.
+> Miksi kirjasto on rakennettu näin. Arvot, periaatteet ja reunaehdot, joiden varaan arkkitehtuuri nojaa.
 >
-> Tämä dokumentti on **normatiivinen** — arkkitehtuurin on noudatettava näitä
-> periaatteita. Jos ehdotettu muutos on ristiriidassa rationalen kanssa,
-> rationalen on muututtava ensin.
+> Tämä dokumentti on **normatiivinen** — arkkitehtuurin on noudatettava näitä periaatteita. Jos ehdotettu muutos on ristiriidassa rationalen kanssa, rationalen on muututtava ensin.

 ---

 ## Miksi tämä projekti on olemassa

-Mikropalveluarkkitehtuurissa jokainen palvelu tarvitsee CI-putken: testit,
-laatutarkistukset, buildin, kontituksen ja julkaisun. Ilman jaettua
-kirjastoa jokainen tiimi kopioi saman YAML-boilerplaten, tekee omat
-virheensä ja ylläpitää omaa versiotaan. Ajan myötä putket ajautuvat erilleen
-— toisessa on `shell: bash`, toisessa ei; toinen käyttää `set -o pipefail`,
-toinen kadottaa exit-koodin `tee`:hen.
+Organisaatiolla on tuotannossa Jenkins-pohjainen CI-järjestelmä (`ci-jenkins-library`, 53 lähdetiedostoa, 21 Cucumber-featurea), joka on osoittautunut toimivaksi vuosien ajan. Se integroi Git-commitit, testiraportoinnin, Docker-buildit, deploymentin ja test flow'n yhtenäiseksi putkeksi, jossa jokainen vaihe raportoi tilansa suoraan Git-committiin.

-Tämä kirjasto on se mitä kopioidaan. Se tarjoaa valmiit, testatut,
-dokumentoidut rakennuspalikat joista jokainen tiimi kokoaa oman putkensa.
-Palikat ovat Gitea Actionsin `uses:`-direktiivillä kutsuttavia reusable
-workflow'ta — ei asennusta, ei runtime-riippuvuutta, ei versiopäivityksiä
-projekteihin.
+Jenkins on kuitenkin raskas ylläpitää Kubernetesissa, ja organisaatio on siirtymässä Giteaan. Tavoitteena on **sama toiminnallisuus, pienemmällä ylläpitotaakalla**, hyödyntäen Gitea Actionsin natiiveja ominaisuuksia.
+
+Kirjasto ei ole Jenkins-migraatiotyökalu. Se on Gitea Actions -natiivi
+uudelleensuunnittelu, joka säilyttää Jenkins-version todistetut patternit
+mutta hylkää ne osat, jotka olivat sidottuja Jenkinsin arkkitehtuuriin.
+Gitea Actionsin ja Gitean natiiveja ominaisuuksia hyödynnetään aina kun
+mahdollista — uutta kilpailevaa toteutusta ei kirjoiteta, jos toimiva
+ratkaisu on jo olemassa.

 ---

 ## Suunnitteluperiaatteet

-### 1. Palikka-arkkitehtuuri: pieniä, vaihdettavia, yhden vastuun workflow'ta
+### 1. Hyödynnä natiivia

-Jokainen provider-workflow tekee yhden asian:
+Gitea Actionsin ja Gitean natiiveja ominaisuuksia käytetään aina kun ne
+riittävät. Uutta kilpailevaa toteutusta ei kirjoiteta, jos toimiva ratkaisu
+on jo olemassa.

-| Workflow | Vastuu |
-|---|---|
-| `config-provider.yml` | Lataa ja validoi konfiguraatio |
-| `check-version.yml` | Tarkistaa onko commit buildattu, laskee version |
-| `docker-build-push.yml` | Buildaa, puskea ja tagittaa kontin |
+**Miksi:** Oma toteutus on aina ylläpidettävä, testattava ja
+dokumentoitava. Natiivi ominaisuus tulee ilmaiseksi, kehittyy alustan
+mukana ja on käyttäjälle tuttu.

-Mikään workflow ei kutsu toista provider-workflowta. Consumer
-— siis mikropalvelun oma pipeline-tiedosto — on ainoa paikka joka
-tietää mitä palikoita tarvitaan ja missä järjestyksessä.
+**Esimerkkejä:**
+- Gitea Actions näyttää jobien statuksen automaattisesti — omaa
+  commit-status API -kutsua ei tarvita jokaiselle vaiheelle
+- Gitea organization secrets/variables korvaa erillisen credential-hallinnan
+- Reusable workflow -mekanismi korvaa custom action -runtimen

-**Miksi:** Tämä on sama periaate kuin Unix-putkissa tai mikropalveluissa:
-pieniä, itsenäisiä komponentteja jotka tekevät yhden asian hyvin.
-Consumer voi vaihtaa yhden palikan toiseen — esimerkiksi Docker-buildin
-tilalle Maven-paketoinnin — ilman että muut palikat muuttuvat.
-Ratkaisu ei ole se että kaikki ajetaan, vaan se että jokainen tiimi
-valitsee mitä tarvitsee. Monoliittinen "kaikki yhdessä" -workflow
-pakottaisi jokaisen tiimin ajamaan tarpeettomia vaiheita.
+### 2. Git-commit on universaali statusnäkymä

-### 2. Gitea ensin — hyödynnä alustaa, älä taistele sitä vastaan
+Buildin jokainen vaihe raportoi tilansa Git-committiin. Kehittäjä näkee yhdellä silmäyksellä, missä vaiheessa build on — ei tarvitse navigoida CI-järjestelmän UI:hun.

-Gitea Actions tarjoaa kolme asiaa ilmaiseksi:
+**Miksi:** Jenkins-versio osoitti, että commit-statusviestit poistavat tarpeen CI-dashboardille. Kehittäjä työskentelee Gitissä, joten status kuuluu Gitiin. Statusviestien `url`-kenttä linkittää suoraan raportteihin — Cucumber-tulokset, SonarQube-tulokset, Docker-rekisteri — ilman että URL tarvitsee etsiä erikseen.

-1. **Jobien visuaalinen status** — jokainen jobi näkyy automaattisesti
-   commit-näkymässä checkmarkilla, spinnerillä tai ristillä.
-2. **Cross-job riippuvuudet** — `needs` hoitaa virheiden propagointin:
-   jos edeltävä jobi feilaa, riippuvat jobit skipataan.
-3. **Reusable workflow -jakelu** — `uses: org/repo/.gitea/workflows/file.yml@v1`
-   on natiivisti versioitu, skopattu ja välimuistitettu.
+**Mitä tarkoittaa käytännössä:** Gitea Actions näyttää jobien tilan
+(checkmark/risti/spinner) commit-näkymässä automaattisesti. API:a
+(`/api/v1/repos/{owner}/{repo}/statuses/{sha}`) käytetään vain
+custom-raporttilinkin välittämiseen. ADR 0004.

-Kirjasto käyttää näitä kaikkia. Ei omaa tilakonetta, ei custom
-action -runtimea, ei ulkoista orkestraattoria.
+### 3. Reusable workflow — ei omaa runtimea

-**Esimerkki:** Tool-jobit eivät kutsu commit-status API:a lainkaan.
-Gitean oma job-status riittää — `success`/`failure`/`running` näkyy
-automaattisesti. API:a käytetään vain kun tarvitaan **custom-linkki**
-(testiraporttiin tai Docker registryyn), jota natiivistaatus ei tarjoa.
-Tämä linjaus on dokumentoitu ADR 0004 ja 0007:ssä.
+Kirjasto jaetaan Gitea Actionsin reusable workflow -mekanismilla. Ei Docker-pohjaisia custom actioneita, ei erillistä ajonaikaista palvelinta.

-### 3. Status näkyy siellä missä työ tehdään — Git-commitissa
+**Miksi:** Reusable workflow on Gitea Actionsin natiivein tapa jakaa CI-logiikkaa. Se on kevein (ei ylimääräistä runtimea), läpinäkyvin (workflow-tiedosto on luettavissa sellaisenaan) ja teknisesti kestävin (Gitea huolehtii versioinnista ja jakelusta). Custom actionit otetaan käyttöön vain jos reusable workflow'n rajat tulevat vastaan.

-Kehittäjä työskentelee Gitissä. `git log`, `git blame`, PR-näkymä —
-nämä ovat päivittäiset työkalut. CI-statuksen kuuluu näkyä siellä,
-ei erillisessä dashboardissa.
+**Mitä tämä ei ole:** Tämä ei ole monorepo-työkalu, joka asennetaan projekteihin. Tämä on joukko `.gitea/workflows/`-tiedostoja, joihin mikropalvelut viittaavat `uses:`-direktiivillä.

-Gitea Actionsin natiivi job-status tekee tämän automaattisesti:
-jokainen commit näyttää välittömästi mitkä jobit on ajettu ja millä
-tuloksella. Testiraportteihin pääsee yhdellä klikkauksella commitin
-status-kuvakkeesta — koska `report-status.sh` asettaa `target_url`:n
-osoittamaan suoraan HTML-raporttiin git-pagesissa.
+### 4. Konfiguraatio kuuluu repoon

-Tämä ei ole kosmeettinen yksityiskohta. Se on devops-käytännön
-ydin: palautesilmukka on lyhin mahdollinen. Commit → build → status
-näkyy samassa näkymässä jossa kehittäjä jo on.
+Projektikohtainen konfiguraatio (`ci-flow-values.yaml`-tyyppinen tiedosto) asuu mikropalvelun omassa repossa. Reusable workflow lukee sen, ei toisinpäin.

-### 4. Exit-koodi on ainoa totuus
+**Miksi:** Mikropalvelun kehittäjä omistaa buildinsa. Hän tietää mitä Dockefileä käytetään, mitä SonarQube-projektia, mitä testi-steppejä tarvitaan. Jos konfiguraatio hajautetaan useaan repoon, muutokset vaativat koordinaatiota, ja yhden totuuden lähteen periaate rikkoutuu.

-CI-putken jokaisen `run`-stepin onnistuminen määräytyy **vain ja
-ainoastaan** exit-koodin perusteella. Ei tiedoston olemassaolon, ei
-stdout-tulosteen, ei arvauksen. `0` = ok, kaikki muu = ei ok.
+**Poikkeus:** Infra-tason asetukset (git-pages host, Gitea-instanssin URL)
+ovat organisaatiotasolla Gitean organization secrets/variables
+-mekanismissa. Ne eivät ole repokohtaisia.

-Tämä kuulostaa itsestään selvältä, mutta YAML-pipelineissa se rikkoutuu
-helposti. Pipe (`|`) `tee`:hen syö exit-koodin. Tiedoston olemassaolon
-tarkistus (`[ -f results.xml ]`) ei kerro testien läpimenosta.
+### 5. Deterministinen testigraafi, vaiheittainen suoritus

-**Käytännössä:** Jokainen `run`-steppi ottaa exit-koodin talteen
-`$?`-muuttujaan ennen kuin mikään muu komento ehtii muuttaa sitä,
-ja stepin viimeinen rivi on `exit ${EXIT}`. Pipeä ei käytetä
-työvaiheen viimeisenä komentona. Ks. ADR 0008.
+Test flow on tunnettu ennen buildin alkua, ja testit ajetaan yksi kerrallaan. Jos steppi epäonnistuu, koko flow pysähtyy.

-### 5. Pienin mahdollinen pinta-ala
+**Miksi:** Rinnakkainen suoritus aiheuttaa resurssikilpailua (erityisesti suorituskykytestit) ja piilottaa virheitä. Kun integraatiotesti epäonnistuu, e2e-testien ajaminen on turhaa — konttia ei viedä tuotantoon, eikä kukaan lue niitä tuloksia. Vaiheittainen suoritus on deterministinen, debuggattava ja säästää CI-minuutteja.

-Jokainen ylimääräinen riippuvuus on ylimääräinen vikaantumispiste.
-Kirjaston ainoat riippuvuudet:
+**Miten:** Orkestroiva workflow käyttää Gitea REST API:a workflow-dispatchiin ja pollaa ajettavan workflow'n tilaa synkronisesti (`GET /api/v1/repos/{owner}/{repo}/actions/runs/{id}`). Tämä vastaa Jenkinsin `buildJob()`-kutsun semantiikkaa, mutta toteutetaan curl + pollaus -silmukalla.

- Gitea Actions (alusta)
- `bash`, `curl`, `jq` (ubuntu-latest runnerissa valmiina)
- Docker (runnerissa valmiina)
- git-pages (raporttien hostaus, erillinen palvelu)
+### 6. Raporttien hallinta erillisellä palvelulla

-Ei Pythonia, ei Node.js:ää ajonaikaisesti (testit omissa konteissaan).
-Ei tietokantaa. Ei ulkoista tilanhallintaa. Kirjasto on joukko
-YAML-tiedostoja ja shell-skriptejä — samat työkalut jotka jokainen
-devops-ihminen jo osaa.
+Raporttien selailtavuudesta ja elinkaaresta vastaa erillinen palvelu, joka
+asennetaan git-pages Helm-chartilla. Raportit ovat julkisia URL:lla
+(osoite tunnettava). URL linkitetään Git-committiin.

-### 6. Konfiguraatio repoon, salaisuudet Giteaan
+**Miksi:** Jenkins-versiossa linkki Cucumber-raporttiin oli kriittinen
+feature. Gitea Actionsin artifact-järjestelmä ei tue HTML-selailtavuutta
+(vain ZIP-lataus). Erillinen palvelu mahdollistaa hallitun retention ja
+pääsyn ilman CI-alustan rajoitteita.

-Projektikohtainen konfiguraatio (`.gitea/workflows/gitea-env.conf`)
-asuu mikropalvelun omassa repossa. Kehittäjä omistaa sen — hän tietää
-mikä on Docker-imagen nimi, mihin registryyn puskea, mikä on
-testiympäristön URL.
+### 7. Yksi CI-alusta, yksi integraatiopiste

-Salaisuudet (tokenit, salasanat) elävät Gitean secrets-mekanismissa,
-eivät repon tiedostoissa. `secrets: inherit` välittää ne providerin
-workflow'hun ilman että consumerin tarvitsee tietää mitä salaisuuksia
-mikäkin provider tarvitsee.
+Kirjasto tukee vain Giteaa. Ei GitLab-, BitBucket- tai GitHub-abstraktioita.

-Poikkeus: infra-tason asetukset (`GIT_PAGES_URL`, `GITEA_API_URL`)
-ovat Gitean organization secrets/variables -mekanismissa. Ne eivät
-ole repokohtaisia.
+**Miksi:** Jenkins-versio tuki neljää Git-alustaa, koska Jenkins itsessään ei tarjonnut commit-statusraportointia. Gitea Actionsissa tilanne on päinvastainen — Gitea on sekä CI-että Git-alusta. Multi-platform-tuesta tulisi pelkkää ylimääräistä abstraktiota ilman konkreettista tarvetta.

-### 7. Consumer omistaa orkestroinnin, provider tarjoaa palikat
+**Mitä tarkoittaa tulevaisuudessa:** Jos toinen alusta tulee ajankohtaiseksi, Gitea-versiota käytetään joko pohjana redesignille tai mallina erilliselle toteutukselle. Rajapintoja ei suunnitella etukäteen alustariippumattomiksi — se on ennenaikaista optimointia.

-Tämä on kirjaston tärkein arkkitehtuurinen päätös (ADR 0005).
+### 8. Cross-repo commit traceability

-Provider (`gitea-ci-library`) ei tiedä mitä testejä ajetaan, missä
-järjestyksessä, tai millä branchilla. Se tarjoaa kolme reusable
-workflow'ta ja joukon skriptejä.
+Kun build-ketju ylittää reporajat (mikropalvelu → deployment → integraatiotestit → e2e-testit), jokainen vaihe raportoi kahteen suuntaan: omaan committiinsa ja takaisin root-committiin, josta ketju käynnistyi.

-Consumer (mikropalvelun `example-feature.yml` / `example-main.yml`)
-päättää:
- Mitkä palikat kutsutaan
- Missä järjestyksessä (`needs`)
- Millä branch-ehdoilla (`if`)
- Mitkä testikontit käytetään (input-parametrit)
+**Miksi:** Kehittäjän ei pidä arvailla mikä versio on missäkin ympäristössä. Kun mikropalvelun commitista näkee koko ketjun — buildattu, deployattu stagingiin, integraatiotestit ajettu, e2e hyväksytty — virheenjäljitys on suora polku commitista ympäristöön. Vastaavasti Helm-repon commit kertoo mikä konttiversio sinne deployattiin ja kenen mikropalvelu-commitista se tuli. Tämä on Jenkins-version **eniten arvoa tuottanut ominaisuus**.

-Tämä on tarkoituksellinen vallanjako. Provider ei voi tietää jokaisen
-tiimin tarpeita — eikä sen pidäkään. Consumer ei voi muuttaa providerin
-sisäistä toteutusta — eikä sen pidäkään. Rajapinta on `workflow_call` ja
-se on molemmille osapuolille selvä.
+**Mekanismi:**

-### 8. Branch-kohtainen reititys, ei yhtä kaikille
+```mermaid
+%%{init: {'theme': 'base'}}%%
+sequenceDiagram
+    participant MR as Mikropalvelu-repo
+    participant HR as Helm-repo
+    participant TR as Testi-repo
+    participant GA as Gitea API

-Eri brancheilla on eri tavoite:
+    Note over MR: commit abc123
+    Note over MR: build kontti v1.2.3

- **Feature-haara:** Onko koodi laadukasta? → testit, validointi
- **Main-haara:** Onko tästä versiosta jo artifakti? Jos ei →
-  testit + build + push + tag. Jos on → ei tehdä mitään (tai
-  jatketaan klusteritesteihin).
+    MR->>GA: POST dispatch deploy-workflow
+    GA->>HR: workflow käyntiin
+    Note over HR: commit def456
+    Note over HR: container.version = 1.2.3

-Tämä logiikka elää consumerin pipeline-tiedostossa, ei providerissa.
-Se on puhdasta `if`-ehtoa ja `needs`-ketjutusta — ei skriptausta,
-ei monimutkaisia ehtoja providerin sisällä.
+    HR->>GA: POST status "deployed by abc123"
+    GA->>MR: Status: deployed to staging
+    Note right of MR: URL → def456

-### 9. Raportit erillisellä palvelulla, linkit commitissa
+    HR->>GA: POST status "from abc123"
+    GA->>HR: Status: from abc123
+    Note right of HR: URL → abc123

-Gitea Actionsin artifact-järjestelmä on binääriarkisto — ZIP-lataus,
-ei HTML-selailtavuutta. Testiraportit (Cucumber HTML, Bats-coverage)
-on voitava avata selaimessa yhdellä klikkauksella.
+    MR->>GA: POST dispatch integraatiotestit
+    GA->>TR: workflow käyntiin
+    Note over TR: commit ghi789

-Ratkaisu: git-pages Helm-chartti, joka tarjoaa staattista
-tiedostohostingia HTTP:llä. `publish-git-pages.sh` vie raportit
-sinne; `report-status.sh` linkittää commit-statuksen suoraan
-raporttiin. Retention hoitaa git-pagesin sidecar automaattisesti.
+    TR->>GA: POST status "integration OK"
+    GA->>MR: Status: integration OK
+    Note right of MR: URL → ghi789

-Tulevaisuudessa `GITHUB_STEP_SUMMARY` (Gitea 1.27+) tarjoaa
-vaihtoehtoisen kanavan: jobin Summary-välilehdelle renderöityvä
-Markdown-taulukko kaikista raporttilinkeistä.
+    TR->>GA: POST status "tested v1.2.3"
+    GA->>HR: Status: tested v1.2.3
+    Note right of HR: URL → def456

-### 10. Vain Gitea — ei monialustatukea ilman tarvetta
+    TR->>GA: POST status "tested abc123"
+    GA->>MR: Status: tested abc123 (root)
+    Note right of MR: URL → abc123
+```

-Yhden alustan tukeminen kunnolla on vaikeampaa kuin kolmen tukeminen
-huonosti. Gitea Actionsin `uses:`-mekanismi, `needs`-semantiikka,
-`secrets: inherit`, `gitea`-konteksti — nämä ovat alustakohtaisia
-ominaisuuksia joita abstraktiokerros vain haittaisi.
-
-Jos toinen alusta tulee ajankohtaiseksi, sille kirjoitetaan oma
-toteutus. Siihen asti yksi alusta riittää. Ennenaikainen yleistys
-on devopsissa yhtä haitallista kuin ohjelmistosuunnittelussa.
+**Mitä tarkoittaa käytännössä:** Jokaisella workflow'lla on kaksi build-referenssiä: `current` (oma commit) ja `root` (mikropalvelun commit, josta ketju alkoi). Molempiin POSTataan statusviestit. Root-build kulkee workflow-dispatchin `inputs`-parametrina koko ketjun läpi. Deployment-job raportoi sekä Helm-repon committiin ("from abc123") että mikropalvelun committiin ("deployed to staging → def456"). Testi-job raportoi omaan committiinsa, mikropalvelun committiin ja Helm-repon committiin.

 ---

@@ -197,31 +152,23 @@ on devopsissa yhtä haitallista kuin ohjelmistosuunnittelussa.

 ### Mitä kirjasto EI tee

- **Ei ulkoista orkestraattoria.** Pipeline-ohjaus on Gitea Actionsin
-  `needs`-ketjuissa ja consumerin `if`-ehdoissa.
- **Ei custom actioneita.** Reusable workflow on kevyempi, versioitu
-  ja jaeltu Gitean oman mekanismin kautta.
- **Ei asennusta projekteihin.** Consumer viittaa `uses:`-direktiivillä
-  suoraan tämän repon workflow-tiedostoihin. Ei npm-pakettia, ei
-  git-submodulea, ei kopioitavia tiedostoja.
- **Ei runtime-riippuvuuksia.** Provider-skriptit käyttävät vain
-  työkaluja jotka ovat Gitea Actionsin `ubuntu-latest` runnerissa
-  valmiina: `bash`, `curl`, `jq`.
- **Ei monorepo-konfiguraatiota.** Jokainen mikropalvelu omistaa
-  oman pipeline-tiedostonsa ja konfiguraationsa.
+- **Ei ulkoista orkestraattoria.** Test flow -ketjutus perustuu Gitean REST APIin ja workflowhin itseensä. Ei erillistä palvelinta, joka hallinnoi tilaa.
+- **Ei Jenkins-migraatiota.** Vanhaa Jenkinsfileä ei voi ajaa Gitea Actionsissa. Tämä on uusi kirjasto uudella konfiguraatioformaatilla.
+- **Ei reaaliaikaista build-seurantaa.** Commit-statusviestit ovat pollattavia, eivät push-pohjaisia. Gitean UI hoitaa reaaliaikaisuuden.
+- **Ei multi-repo-monorepo-konfiguraatiota.** Jokainen mikropalvelu omistaa oman `ci-flow-values.yaml`:nsa. Jaettua konfiguraatiota ei ole projektitasolla.

 ---

 ## Mitä tietoisesti hylättiin

+## Mitä tietoisesti hylättiin
+
 | Hylätty | Syy |
-|---|---|
-| Monoliittinen "kaikki yhdessä" -workflow | Pakottaa kaikille samat vaiheet. Palikka-arkkitehtuuri antaa jokaiselle tiimille vain mitä se tarvitsee |
-| Oma orkestraattoripalvelin | Ylimääräinen ylläpidettävä. Gitean `needs` ja `if` riittävät |
-| Docker-pohjaiset custom actionit | Tuovat riippuvuuden Docker-rekisteriin. Reusable workflow on natiivimpi |
-| Commit-status API jokaiselle vaiheelle | Duplikointia — Gitea näyttää job-statuksen automaattisesti. API vain custom-linkeille |
-| `tee`-putki debug-näkyvyyteen | Syö exit-koodin. stdout ohjataan tiedostoon `>` ilman pipeä |
-| Multi-Git-platform-tuki | Ennenaikaista optimointia ilman tarvetta |
-| Gitea Packages raporttien hostingiin | Ei HTML-selailtavuutta — vain binäärilataus |
-| Gitea Pages + reports-branch | Race condition rinnakkaisten pushien kanssa |
-| `repository_dispatch` ketjutukseen | Lisää konfiguraatiota vastaanottaviin repoihin. Suora API-kutsu eksplisiittisempi |
+|---------|-----|
+| Multi-Git-platform-tuki (GitLab, BitBucket) | Vain Gitea on relevantti. Abstraktointi ilman tarvetta on turhaa kompleksisuutta |
+| Gitea Packages raporttien hostingiin | Ei tue HTML-selailtavuutta — vain binääriartefaktien lataus |
+| Gitea Releases raporttien hostingiin | Saastuttaa release-historian. Satoja CI-raportteja oikeiden julkaisujen seassa |
+| Gitea Pages + reports-branch | Race condition rinnakkaisten buildien pushissa samaan branchiin |
+| Ulkoinen orkestraattoripalvelin | Ylimääräinen ylläpidettävä. Gitean oma API riittää |
+| Docker-pohjaiset custom actionit | Tuovat riippuvuuden Docker-rekisteriin ja monimutkaistavat jakelua. Otetaan käyttöön vain pakon edessä |
+| `repository_dispatch` (webhook) test flow -ketjutukseen | Lisää konfiguraatiota vastaanottaviin repoihin. Suora REST API -kutsu on eksplisiittisempi ja debuggattavampi |
@@ -1,6 +1,8 @@
 # Vaatimukset — Gitea Actions CI -kirjasto

 > Funktionaaliset vaatimukset käyttäjän näkökulmasta. Muoto: käyttötapaukset (use cases).
+>
+> Linkittyy: [design-rationale.md](design-rationale.md), [architecture.md](architecture.md), [report-hosting.md](report-hosting.md)

 ---

@@ -11,89 +13,130 @@

 **Main success:**
 - Kehittäjä avaa commitin Giteassa
- Näkee job-statukset automaattisesti: spinner (käynnissä), checkmark (ok), risti (feilasi)
- Testijobit näyttävät statuksen linkillä: "unit-tests Link to Bats reports", "acc-tests Link to Cucumber reports"
- Klikkaamalla testistatusta kehittäjä pääsee suoraan HTML-raporttiin git-pagesissa
- Docker-build näyttää linkin konttirekisteriin
+- Näkee statusviestit: "Building...", "Unit tests OK", "Docker build OK", "Docker pushed"
+- Jokainen statusviesti on klikattavissa → vie buildin sivuun tai raporttiin
+- Epäonnistunut steppi näkyy punaisella — kehittäjä klikkaa ja näkee mikä meni vikaan

 **Poikkeukset:**
 - Statusviesti puuttuu (workflow kaatui ennen raportointia) → commitissa näkyy timeout/error
- Useampi workflow samalle commitille → statukset erottuvat `context`-avaimella
+- Useampi workflow samalle commitille → statukset erottuvat `key`-arvolla

 ---

 ## UC2: Kehittäjä lukee testiraportteja selaimessa

 **Actor:** Kehittäjä
-**Precondition:** Build on valmistunut, raportit julkaistu git-pagesiin
+**Precondition:** Build on valmistunut, raportit pushattu Minioon

 **Main success:**
- Kehittäjä klikkaa commitin status-kuvaketta (esim. "unit-tests")
- Selain avautuu suoraan HTML-raporttiin git-pagesissa
- Bats-raportissa näkyy: testitulokset, code coverage
- Cucumber-raportissa näkyy: mitkä testit menivät läpi, mitkä epäonnistuivat, stack tracet
+- Kehittäjä klikkaa commitin statusviestin URL:ää ("Unit tests OK" → URL)
+- Selain avautuu, OIDC-kirjautuminen (Gitea-tunnuksilla)
+- Cucumber-raportti renderöityy HTML:nä selaimessa
+- Raportissa näkyy: mitkä testit menivät läpi, mitkä epäonnistuivat, stack tracet
+- Yläreunassa linkki "← Back to build" → palaa buildin raportti-indeksiin

 **Poikkeukset:**
- Raporttia ei ole (testit skipattiin, workflow kaatui ennen julkaisua) → 404
+- Raporttia ei ole (testit skipattiin, workflow kaatui ennen pushausta) → 404
+- OIDC-sessio vanhentunut → uudelleenohjaus kirjautumiseen

 ---

-## UC3: Kehittäjä vertailee kahden buildin raportteja
+## UC3: Kehittäjä selaa projektin build-historiaa
+
+**Actor:** Kehittäjä
+**Precondition:** Projektilla on vähintään yksi build
+
+**Main success:**
+- Kehittäjä menee `{MINIO_BASE}/{repo_slug}/index.html`
+- Näkee listan kaikista buildeista aikajärjestyksessä (uusin ensin)
+- Jokaisella buildilla: commitin 8-merkkinen hash, päivämäärä, branch, status (✅/❌)
+- Klikkaa buildia → siirtyy `{commit_short}/index.html` — buildin raporttilistaukseen
+- Buildin sivulla: lista kaikista raporteista (Cucumber, JaCoCo, Maven Site) linkkeinä
+- "← Back to builds" → palaa projektin build-indeksiin
+
+**Poikkeukset:**
+- Projekti poistettu / siivottu retention policyn mukaan → 404
+- Indeksitiedosto puuttuu (ensimmäinen build kesken) → 404, generoituu seuraavalla pushauksella
+
+---
+
+## UC4: Kehittäjä jäljittää kontin koko ketjun commitista
+
+**Actor:** Kehittäjä
+**Precondition:** Mikropalvelun commitista on ajettu vähintään deployment
+
+**Main success:**
+- Kehittäjä avaa mikropalvelun commitin abc123
+- Näkee statusviestit: "Build OK", "Deployed to staging → def456", "Integration tests OK → ghi789"
+- Klikkaa "Deployed to staging → def456" → siirtyy Helm-repon committiin def456
+- Helm-repon commitissa näkyy: "from abc123", "tested v1.2.3", "tested abc123"
+- Klikkaa "tested abc123" → palaa mikropalvelun committiin
+- Koko ketju on navigoitavissa edestakaisin commit-statuslinkkien kautta
+
+**Poikkeukset:**
+- Välivaiheen commit siivottu → statusviesti jää, mutta linkki vie 404:ään
+- Deploytty versio ei vastaa odotettua → statusviestissä näkyy ristiriita
+
+---
+
+## UC5: Kehittäjä näkee deployatun version ympäristössä
+
+**Actor:** Kehittäjä
+**Precondition:** Deployment on suoritettu, Helm-repon commit tehty
+
+**Main success:**
+- Kehittäjä avaa Helm-repon commitin def456
+- Näkee: "container.version = 1.2.3", "Deployed by abc123"
+- Tietää heti mikä konttiversio on missäkin ympäristössä
+- Voi verrata mikropalvelun uusimpaan commitin — onko ympäristö ajan tasalla?
+
+**Poikkeukset:**
+- `doNotDowngrade` esti deploymentin → statusviesti "Skipped: newer version already deployed"
+
+---
+
+## UC6: Testi-insinööri näkee mitä konttia testattiin
+
+**Actor:** Testi-insinööri
+**Precondition:** Integraatio- tai e2e-testit on ajettu
+
+**Main success:**
+- Avaa testi-repon commitin ghi789
+- Näkee: "Tested v1.2.3" (mikä kontti), "Tested abc123" (mikä mikropalvelun commit)
+- Klikkaa testiraporttiin → näkee tulokset
+- Näkee myös mitkä tagit olivat käytössä (`@smoke and not @slow`)
+- Voi todentaa että testattiin oikeaa versiota
+
+**Poikkeukset:**
+- Version check epäonnistui (haluttu versio ei ollut ympäristössä) → status: "Version mismatch"
+- Testit keskeytyivät timeoutiin → status: timeout, osittaiset tulokset raportissa
+
+---
+
+## UC7: Kehittäjä vertailee kahden buildin raportteja

 **Actor:** Kehittäjä
 **Precondition:** Projektilla on vähintään kaksi buildia

 **Main success:**
- Kehittäjä avaa kaksi buildia Gitean Actions-näkymässä eri välilehtiin
+- Kehittäjä avaa projektin build-indeksin `{MINIO_BASE}/{repo}/index.html`
+- Näkee viimeisimmät buildit vierekkäin
+- Avaa kaksi buildia eri välilehtiin
 - Voi verrata Cucumber-tuloksia: "build #42 vs #41 — mikä testi meni rikki?"

---
-
-## UC4: Kehittäjä jäljittää kontin koko ketjun commitista (tuleva)
-
-**Actor:** Kehittäjä
-**Precondition:** Mikropalvelun commitista on ajettu deployment ja klusteritestit
-
-**Main success:**
- Kehittäjä avaa mikropalvelun commitin
- Näkee statusviestit: "Build OK", "Deployed to staging", "Integration tests OK"
- Klikkaamalla statusta siirtyy toisen repon committiin
- Koko ketju on navigoitavissa edestakaisin commit-statuslinkkien kautta
-
---
-
-## UC5: Kehittäjä näkee deployatun version ympäristössä (tuleva)
-
-**Actor:** Kehittäjä
-**Precondition:** Deployment on suoritettu
-
-**Main success:**
- Avaa Helm-repon commitin
- Näkee suoraan mikä konttiversio on deployattu
- Voi verrata mikropalvelun uusimpaan commitiin — onko ympäristö ajan tasalla?
-
---
-
-## UC6: Kehittäjä saa Gitea 1.27+ Summary-näkymän raporttilinkeistä (tuleva)
-
-**Actor:** Kehittäjä
-**Precondition:** Gitea 1.27+ ja päivitetty runner
-
-**Main success:**
- Avaa workflow'n Gitea Actionsissa
- "Report Summary" -jobin Summary-välilehdellä näkyy taulukko linkeillä kaikkiin raportteihin
- Yhdellä silmäyksellä näkee mitä testejä ajettiin ja pääsee klikkaamalla raportteihin
+**Poikkeukset:**
+- Vanha build siivottu → ei näy indeksissä

 ---

 ## Ei-toiminnalliset vaatimukset

 | Vaatimus | Toteutus |
-|---|---|
-| Raportit selailtavissa HTML:nä | git-pages static hosting |
-| Linkki commitista suoraan raporttiin | Commit-status API:n `target_url` |
-| Raporttien pysyvyys | git-pages retention sidecar |
-| Virheiden propagointi | Gitea Actions `needs`-ketju |
-| Pipeline-pysäytys virhetilanteessa | `needs` automaattinen skip |
-| Exit-koodi ainoa totuus | ADR 0008 |
-| Statusraportointi vain raporttilinkeille | ADR 0007 |
+|----------|----------|
+| Raportit selailtavissa HTML:nä | MinIO static web hosting |
+| Linkki commitista suoraan raporttiin | Statusviestin `url`-kenttä |
+| Build-indeksi per projekti | Generoitu `index.html` Minioon |
+| Navigaatio raporttien välillä | "Back to build" / "Back to builds" — linkit indeksisivuilla |
+| Cross-repo-navigaatio | Statusviestit linkittävät repoja ristiin |
+| Raporttien pysyvyys | ConfigMap-pohjainen retention policy |
+| Autentikointi | OIDC (Traefik middleware, Gitea OAuth2) |
@@ -18,7 +18,7 @@ Runnerilla on yksi vastuu: **suorittaa workflow-steppejä**. Kaikki runtime-ymp

 ## Kontit ja palvelut

-Jokainen job voi määritellä käyttämänsä kontit. Eri jobeilla voi olla eri kontti:
+Jokainen job voi määritellä käyttämänsä kontit. Tämä vastaa Jenkinsin pod template -konseptia, mutta on yksinkertaisempi:

 ### `container:` — ajonaikainen ympäristö

@@ -99,3 +99,13 @@ Eri labelit mahdollistavat erikoistuneet runnerit (ARM, GPU, Windows), mutta MVP
 |------|-------|-------|--------------|
 | **Global** | Kaikki organisaatiot ja repot | Token-vuoto → hyökkääjä voi ajaa koodia missä tahansa | Jaettu infra, keskitetty hallinta |
 | **Organization** | Yhden organisaation repot | Rajoittuu yhteen orgiin | Per organisaatio, eristetty — **suositeltu** |
+
+## Jenkins-vertailu
+
+| Jenkins | Gitea Actions |
+|---------|--------------|
+| Pod template (YAML) määrittelee kontit | `container:` + `services:` per job |
+| Jokaiselle jobille oma pod | Jokaiselle jobille omat konttimääritykset |
+| DinD sidecar-podissa | `services: docker:dind` samassa jobissa |
+| Agentti = erillinen JVM-prosessi | Runner = kevyt Go-binääri tai K8s-pod |
+| Labelit Jenkins-nodessa | Labelit runner-rekisteröinnissä |
@@ -1,141 +1,197 @@
 # Jaetut skriptit

-> Provider-skriptit asuvat `scripts/`-hakemistossa. Consumer-skriptit
-> asuvat `.gitea/scripts/`-hakemistossa. ADR 0006.
+> ⚠️ **POC-vaihe.** Osa kuvatuista skripteistä (push-reports.sh, tag-commit.sh)
+> on suunniteltu mutta ei toteutettu. Toteutetut: `publish-git-pages.sh`,
+> `report-status.sh`, `dispatch-workflow.sh` (POC-taso).
+>
+> Uudelleenkirjoitus odottaa: skriptien määrä ja rajapinnat voivat muuttua.
+
+Skriptit asuvat `gitea-ci-library/scripts/`-hakemistossa.

 ---

 ## `report-status.sh`

-POSTaa commit-statuksen Gitea REST APIin. Käytetään **vain** kun tarvitaan
-custom-linkki (testiraportti, Docker registry). Tool-jobit luottavat
-Gitean natiiviin job-statukseen. ADR 0007.
+POSTaa build-statuksen Gitea-commitin REST APIin.

 ### Rajapinta

 ```bash
-report-status.sh <state> <description> <context> [suite] [custom_url]
+report-status.sh <state> <description> <url> [key] [root_commit] [root_repo]
 ```

 | Parametri | Pakollinen | Kuvaus |
-|---|---|---|
-| `state` | Kyllä | `pending`, `success`, `failure` |
-| `description` | Kyllä | Ihmisluettava kuvaus |
-| `context` | Kyllä | Uniikki avain (`unit-tests`, `acc-tests`, `ci-docker-build-push`) |
-| `suite` | Ei | Julkaistun raportin suite-nimi → linkki git-pagesiin |
-| `custom_url` | Ei | Oma URL (ohittaa oletus-URL:n generoinnin) |
+|-----------|------------|--------|
+| `state` | Kyllä | `pending`, `success`, `failure`, `error` |
+| `description` | Kyllä | Ihmisluettava kuvaus (esim. "Unit tests passed") |
+| `url` | Kyllä | Linkki buildiin tai raporttiin |
+| `key` | Ei | Uniikki avain. Oletus: `commit-{sha_short}` |
+| `root_commit` | Ei | Root-buildin commit-hash (cross-repo-raportointia varten) |
+| `root_repo` | Ei | Root-buildin repo (cross-repo-raportointia varten) |

 ### Kutsuesimerkkejä

 ```bash
-# Testijobi, linkki git-pages-raporttiin
-report-status.sh success "Link to Bats reports" unit-tests bats
+# Buildin aloitus
+report-status.sh pending "Building..." "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"

-# Docker build, custom URL registryyn
-report-status.sh success "Docker build & push 1.2.0 OK" ci-docker-build-push "" \
-  "https://gitea.example.com/org/-/packages/container/app/1.2.0"
+# Testivaihe valmis, linkki raporttiin
+report-status.sh success "Unit tests OK" "$MINIO_BASE_URL/$GITHUB_REPOSITORY/${GITHUB_SHA::8}/cucumber/overview-features.html" "unit-test"
+
+# Deployment valmis, cross-repo: raportoi takaisin mikropalvelun committiin
+report-status.sh success "Deployed to staging" "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/commit/$GITHUB_SHA" "deploy-staging" "$ROOT_COMMIT" "$ROOT_REPO"
 ```

-### URL-generointi
-
- Jos `suite` annettu → URL: `${GIT_PAGES_URL}/${repo}/reports/${sha8}/${suite}/`
- Jos `custom_url` annettu → käytetään sellaisenaan
- Muuten → URL: `${GITEA_API_URL}/${repo}/actions/runs/${run_id}` (Gitea Actions -loki)
-
 ### Gitea API -kutsu

 ```bash
 curl -X POST "$GITEA_API_URL/api/v1/repos/$REPO/statuses/$COMMIT" \
  -H "Authorization: token $GITEA_TOKEN" \
  -H "Content-Type: application/json" \
-  -d "{\"state\":\"$STATE\",\"target_url\":\"$URL\",\"description\":\"$DESCRIPTION\",\"context\":\"$CONTEXT\"}"
+  -d "{
+    \"state\": \"$STATE\",
+    \"target_url\": \"$URL\",
+    \"description\": \"$DESCRIPTION\",
+    \"context\": \"$KEY\"
+  }"
 ```

---
-
-## `publish-git-pages.sh`
-
-Julkaisee raporttihakemiston git-pages-palveluun PATCH-tar:na.
-
-### Rajapinta
-
-```bash
-publish-git-pages.sh <suite>
-```
-
-| Parametri | Pakollinen | Kuvaus |
-|---|---|---|
-| `suite` | Kyllä | Raporttihakemiston nimi (`bats`, `cucumber`, `junit`, ...) |
-
-### Toiminta
-
-1. Lukee raportit hakemistosta `reports/${SHA8}/${suite}/`
-2. Pakkaa tar:ksi ja PATCHaa git-pagesiin BasicAuthilla
-3. Tulostaa raportin base-URL:n stdoutiin
-
-### Vaaditut env-muuttujat
-
-| Muuttuja | Lähde |
-|---|---|
-| `GITEA_API_URL` | `env_json` → workflow `env:` |
-| `GIT_PAGES_URL` | `env_json` → workflow `env:` |
-| `GIT_PAGES_PUBLISH_TOKEN` | Gitea secret → `env:` |
-| `GITHUB_REPOSITORY` | Automaattinen |
-| `GITHUB_SHA` | Automaattinen |
-
---
-
-## `ci-validate.sh`
-
-Validoi `.conf`-tiedoston ja tarkistaa että pakolliset secretit on asetettu.
-Kutsutaan `config-provider.yml`:stä osana konfiguraation latausta.
-
-### Rajapinta
-
-```bash
-ci-validate.sh
-```
-
-Lukee tiedoston polun `CI_CONF_FILE`-env-muuttujasta (oletus: `.gitea/workflows/gitea-env.conf`).
-
-### Validointisäännöt
-
- `.conf`-tiedosto on olemassa
- Jokaisella `KEY=VALUE`-rivillä on arvo (ei tyhjää)
- URL-tyyppiset avaimet alkavat `http://` tai `https://`
- `GITEA_TOKEN` on asetettu
- `GIT_PAGES_PUBLISH_TOKEN` on asetettu
+Status-arvot mapataan Gitean skeemaan: `pending` (INPROGRESS), `success` (SUCCESS), `failure` (FAILURE), `error` (STOPPED).

 ---

 ## `dispatch-workflow.sh`

 Dispatchaa workflow'n toisessa repossa ja pollaa sen valmistumista synkronisesti.
-Käytetään GitOps-deploymentissa ja klusteritestien ketjutuksessa (tuleva).

 ### Rajapinta

 ```bash
-dispatch-workflow.sh <target_repo> <workflow_file> <ref> <inputs_json> [timeout_minutes]
+dispatch-workflow.sh <target_repo> <workflow_file> <ref> <inputs_json> <gitea_api_url> <gitea_token> [timeout_minutes]
 ```

+| Parametri | Pakollinen | Kuvaus |
+|-----------|------------|--------|
+| `target_repo` | Kyllä | `owner/repo` |
+| `workflow_file` | Kyllä | Workflow-tiedoston nimi (esim. `test.yml`) |
+| `ref` | Kyllä | Branch |
+| `inputs_json` | Kyllä | JSON-objekti input-parametreina |
+| `gitea_api_url` | Kyllä | Gitean API-URL (esim. `https://gitea.example.com`) |
+| `gitea_token` | Kyllä | Gitea API -token |
+| `timeout_minutes` | Ei | Oletus: 360 (6 tuntia) |
+
 ### Toiminta

 1. **Dispatch:** `POST /api/v1/repos/{target_repo}/actions/workflows/{workflow_file}/dispatches`
-2. **Poll:** `GET /api/v1/repos/{target_repo}/actions/runs` → odota valmistumista
-3. **Palauta:** `conclusion` (`success`/`failure`/`timeout`)
+2. **Etsi run:** `GET /api/v1/repos/{target_repo}/actions/runs?status=running` → etsi uusin (aikaleimasta)
+3. **Poll:** `GET /api/v1/repos/{target_repo}/actions/runs/{run_id}` 10s välein
+4. **Lopeta:** Kun `status == "completed"` → palauta `conclusion` (`success`/`failure`/`cancelled`)
+5. **Timeout:** Jos kestää yli `timeout_minutes` → palauta `timeout`
+
+### Kutsuesimerkki
+
+```bash
+dispatch-workflow.sh "tests/integration" "test.yml" "main" \
+  '{"version":"1.2.3","tags":"@smoke","root_commit":"abc123","root_repo":"services/temperature-store"}' \
+  "https://gitea.example.com" "gtp_abc123"
+```
+
+---
+
+## `push-reports.sh` (vanhentunut — korvattu `publish-git-pages.sh`:lla)
+
+Puskaa raporttihakemiston git-pagesiin.
+
+### Rajapinta
+
+```bash
+push-reports.sh <report_type> <source_dir> [index_title]
+```
+
+| Parametri | Pakollinen | Kuvaus |
+|-----------|------------|--------|
+| `report_type` | Kyllä | Raportin tyyppi (`cucumber`, `jacoco`, `junit`, `site`) |
+| `source_dir` | Kyllä | Paikallinen hakemisto, jossa raporttitiedostot |
+| `index_title` | Ei | Näkyvä nimi indeksisivulla (esim. "Cucumber Reports") |
+
+### Toiminta
+
+1. Kopioi raportit: `mc cp --recursive {source_dir} minio/reports/{repo}/{commit_short}/{report_type}/`
+2. Päivitä `/reports/{repo}/{commit_short}/index.html` — lisää linkki tähän raporttiin
+3. Päivitä `/reports/{repo}/index.html` — varmista että tämä build on listalla
+4. Palauta URL: `{MINIO_BASE_URL}/{repo}/{commit_short}/{report_type}/index.html`
+
+### Indeksisivut
+
+**Projektin build-indeksi** (`/reports/{repo}/index.html`):
+- Lista buildeista aikajärjestyksessä (uusin ensin)
+- Jokainen rivi: commit hash (linkki), päivämäärä, status (✅/❌), branch
+
+**Buildin raportti-indeksi** (`/reports/{repo}/{commit_short}/index.html`):
+- Lista raporteista linkkeinä
+- Linkki "← Back to builds" → projektin build-indeksiin
+
+Molemmat generoidaan uudestaan jokaisen pushauksen yhteydessä. Staattinen HTML, ei vaadi palvelinpuolen logiikkaa.
+
+### Kutsuesimerkki
+
+```bash
+push-reports.sh cucumber target/cucumber-report "Cucumber Reports"
+# → https://reports.example.com/temperature-store/abc12345/cucumber/overview-features.html
+
+push-reports.sh jacoco target/jacoco-report "JaCoCo Coverage"
+# → https://reports.example.com/temperature-store/abc12345/jacoco/index.html
+```
+
+---
+
+## `tag-commit.sh`
+
+Tagittaa commitin versiolla Gitea REST API:n kautta.
+
+### Rajapinta
+
+```bash
+tag-commit.sh <version>
+```
+
+### Toiminta
+
+```bash
+curl -X POST "$GITEA_API_URL/api/v1/repos/$GITHUB_REPOSITORY/tags" \
+  -H "Authorization: token $GITEA_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"tag_name\": \"$VERSION\",
+    \"message\": \"Build #$GITHUB_RUN_NUMBER\",
+    \"target\": \"$GITHUB_SHA\"
+  }"
+```
+
+### Kutsu
+
+```bash
+tag-commit.sh "1.2.3.$GITHUB_RUN_NUMBER"
+```
+
+Tagataan vain onnistuneen buildin ja pushin jälkeen. Tämän jälkeen `isContainerBuilt()` palauttaa `true` samalle commitille.

 ---

 ## Muuttujat, joita skriptit olettavat

+Skriptit lukevat nämä Gitea Actionsin ympäristömuuttujat:
+
 | Muuttuja | Lähde | Käyttäjä |
-|---|---|---|
-| `GITEA_API_URL` | `env_json` | `report-status.sh`, `ci-validate.sh` |
-| `GIT_PAGES_URL` | `env_json` | `publish-git-pages.sh`, `report-status.sh` |
-| `GITEA_TOKEN` | Gitea secret | `report-status.sh`, `check-version.yml`, `docker-build-push.yml` |
-| `GIT_PAGES_PUBLISH_TOKEN` | Gitea secret | `publish-git-pages.sh` |
+|----------|-------|----------|
+| `GITEA_API_URL` | Org variable | `report-status.sh` |
+| `GITEA_TOKEN` | Org secret | `report-status.sh`, `tag-commit.sh` |
+| `MINIO_BASE_URL` | Org variable | `push-reports.sh` |
+| `MINIO_ACCESS_KEY` | Org secret | `push-reports.sh` |
+| `MINIO_SECRET_KEY` | Org secret | `push-reports.sh` |
 | `GITHUB_REPOSITORY` | Automaattinen | Kaikki skriptit |
 | `GITHUB_SHA` | Automaattinen | Kaikki skriptit |
-| `GITHUB_RUN_ID` | Automaattinen | `report-status.sh` |
-| `GITHUB_RUN_NUMBER` | Automaattinen | `docker-build-push.yml` (tag-commit) |
+| `GITHUB_SERVER_URL` | Automaattinen | `report-status.sh` |
+| `GITHUB_RUN_ID` | Automaattinen | `report-status.sh`, `tag-commit.sh` |
+| `GITHUB_RUN_NUMBER` | Automaattinen | `tag-commit.sh` |
+| `GITHUB_ACTOR` | Automaattinen | Docker-labelit |
@@ -1,6 +1,7 @@
 # Tech Stack — Gitea Actions CI -kirjasto

-> Katso myös `git-pages/docs/tech-stack.md`.
+> ⚠️ POC-vaihe. Osa teknologiavalinnoista voi muuttua uudelleenkirjoituksen
+> myötä. Katso myös `git-pages/docs/tech-stack.md`.

 ---

@@ -20,22 +21,19 @@ Raportit hostataan git-pages-palvelulla (`git-pages/`-Helm-chartti).
 Julkaisu: `scripts/publish-git-pages.sh` → PATCH tar. Tarkemmat
 teknologiavalinnat: `git-pages/docs/tech-stack.md`.

-Tulevaisuus: `GITHUB_STEP_SUMMARY` (Gitea 1.27+) tarjoaa Summary-näkymän
-suoraan Gitea UI:ssa.
-
 ## Tuetut ulkoiset palvelut

 | Palvelu | Rajapinta | Käyttötarkoitus |
 |---|---|---|
-| **Gitea REST API** | `/api/v1/` | Commit-status, git-tagit, workflow-dispatch |
-| **git-pages** | HTTP (PATCH tar) | Raporttien hostaus |
+| **Gitea REST API** | `/api/v1/` | Commit-status, workflow-dispatch, branch-listaus (retention) |
+| **git-pages** | HTTP | Raporttien hostaus |
 | **Gitea Packages** | Container registry API | Docker-imagen push |

-## Mitä EI tueta
+## Mitä EI tueta (verrattuna Jenkins-versioon)

 | Teknologia | Syy |
 |---|---|
-| **Multi-Git-platform** | Vain Gitea — yksi alusta kunnolla (periaate 10) |
-| **Custom actionit** | Reusable workflow on kevyempi ja natiivimpi (periaate 2) |
-| **Ulkoinen orkestraattori** | Gitean `needs` + `if` hoitaa ohjauksen |
-| **Artifactory/Nexus** | Gitea Packages riittää MVP:ssä |
+| **MinIO** | Korvattu git-pagesilla |
+| **Multi-Git-platform** | Vain Gitea |
+| **Jenkins** (shared library, plugins) | Gitea Actions korvaa |
+| **Artifactory/Nexus** | MVP:ssä ei, factory/adapter-pattern valmiina |
@@ -1,126 +1,390 @@
 # Reusable workflowt

-> Provider-workflowt tarjoavat ydintoiminnallisuuden. Consumer kokoaa ne
-> haluamakseen pipelineksi. Esimerkkitoteutus: `example-*`-tiedostot.
+> ⚠️ **POC-vaihe.** Toteutettu: `quality-gate.yml`. Suunnitteilla:
+> `ci-master.yml`, `deploy.yml`, `test.yml`.

 ---

 ## Yhteiset konventiot

 Kaikki workflowt:
- Käyttävät `concurrency:`-ryhmää estämään saman branchin rinnakkaiset ajot
- Provider-workflowt lukevat konfiguraation inputtina (`env_json`)
- Statusraportointi: tool-jobit natiivilla, test-jobit API:lla raporttilinkin takia (ADR 0007)
- Exit-koodi aina ylös, ei pipeä (ADR 0008)
+- Käyttävät `concurrency:`-ryhmää estämään saman branchin rinnakkaiset ajot (vastaa Jenkins `disableConcurrentBuilds()`)
+- Lukevat konfiguraation `ci-flow-values.yaml`:sta
+- Raportoivat jokaisen vaiheen Gitea-commitin statukseen `report-status.sh`:lla
+- Käyttävät projektilta saatuja `with:`-parametreja konttien määrittelyyn (kirjasto ei pakota konttiversioita)

 ---

-## Provider-workflowt
+## `quality-gate.yml` — Merge-portti

-### `config-provider.yml` — Konfiguraation lataus ja validointi
+**Trigger:** `workflow_call` — consumer kutsuu `uses:`-direktiivillä

-**Trigger:** `workflow_call`
+**Rooli:** Laatuportti, joka ajetaan branch protection -sääntönä ennen PR:n
+sulkemista mainiin. Pipeline on ajettava (`run > 1`) eikä yhtään jobia
+saa failata.

-**Inputs:**
+**Provider-Consumer-malli (ADR 0005):** Provider tarjoaa orkestroinnin
+(validointi, raporttien julkaisu, commit-status). Consumer omistaa
+pipeline-stepit — valitsee testityökalunsa, mahdolliset laatu- ja
+tietoturva-analyy sit sekä niiden järjestyksen. Alla oleva esimerkki
+kuvaa tyypillistä Java-mikropalvelua Mavenilla; consumer korvaa nämä
+omalla tekniikkapinollaan.

-| Parametri | Pakollinen | Kuvaus |
-|-----------|------------|--------|
-| `config_path` | Kyllä | Polku `.conf`-tiedostoon |
+### Inputs (providerin rajapinta)

-**Secrets:**
+| Parametri | Pakollinen | Tyyppi | Kuvaus |
+|-----------|------------|--------|--------|
+| `env_json` | Kyllä | string | JSON-muotoiset ympäristömuuttujat (`GITEA_API_URL`, `GIT_PAGES_URL`) |
+| `*` | — | — | Consumer lisää omat parametrinsa (`maven-image`, `docker-image`, jne.) |
+
+### Secrets

 | Secret | Pakollinen | Kuvaus |
 |--------|------------|--------|
-| `GITEA_TOKEN` | Kyllä | Validointia varten |
-| `GIT_PAGES_PUBLISH_TOKEN` | Kyllä | Validointia varten |
+| `GITEA_TOKEN` | Kyllä | Gitea API-kutsuihin (commit-status) |
+| `GIT_PAGES_PUBLISH_TOKEN` | Kyllä | Raporttien julkaisuun git-pagesiin |

-**Outputs:**
+### Steppi-kaavio (Java-esimerkki)

-| Output | Kuvaus |
-|--------|--------|
-| `env_json` | JSON-muotoiset ympäristömuuttujat |
-| `config_path` | Sama polku takaisin (DRY downstream-käyttöön) |
+```mermaid
+%%{init: {'theme': 'base', 'flowchart': {'arrowheadScale': 2}}}%%
+flowchart TD
+    VAL["validate
+    provider: tarkista
+    CI-konfiguraatio"] --> TEST["test
+    consumer: mvn test
+    → testiraportit + coverage"]

-**Steppi-kaavio:**
-```
-checkout → validate CI config → parse conf to JSON
+    VAL --> AI_SCAN["ai-scan \[optional\]
+    consumer: tietoturva-
+    tai laatu-skannaus"]
+
+    TEST --> SONAR["sonarqube \[optional\]
+    consumer: mvn sonar:sonar
+    → laatupoikkeamat"]
+    TEST --> PUB["publish-reports
+    provider: vie raportit
+    git-pagesiin"]
+
+    SONAR --> PUB
+    AI_SCAN --> PUB
+
+    PUB --> STATUS["commit-status
+    provider: aseta status
+    linkillä raporttiin"]
+
+    FAIL("fail") -. "if: always()" .-> PUB
+
+    style VAL fill:#2563eb,color:#ffffff
+    style TEST fill:#059669,color:#ffffff
+    style SONAR fill:#7c3aed,color:#ffffff
+    style AI_SCAN fill:#7c3aed,color:#ffffff
+    style PUB fill:#0891b2,color:#ffffff
+    style STATUS fill:#f59e0b,color:#111827
+    style FAIL fill:#dc2626,color:#ffffff
+    linkStyle default stroke:#9ca3af,stroke-width:3px
 ```

-### `check-version.yml` — Version ja artifactin tarkistus
+Consumerin omat stepit (test, sonarqube, ai-scan) ovat esimerkki.
+Vastaava rakenne toimii millä tahansa kielellä tai työkalulla.

-**Trigger:** `workflow_call` — käytetään vain main-haarassa
+### Optionaaliset laatu- ja tietoturvaskannaukset

-**Inputs:** `env_json`
+Consumer voi lisätä pipelineen omia skannaussteppejä testien rinnalle.
+Nämä ajetaan rinnakkain `validate`-vaiheen jälkeen ja syöttävät
+raporttinsa providerin `publish-reports`-palveluun. Jokainen skannaus
+on oma Gitea Actions -jobinsa.

-**Outputs:** `artifact_exists` (true/false), `version` (string)
+```mermaid
+%%{init: {'theme': 'base', 'flowchart': {'arrowheadScale': 2}}}%%
+flowchart LR
+    VAL["validate"] --> SAST["sast
+    semgrep / codeql"]
+    VAL --> SCA["sca
+    snyk / owasp dc"]
+    VAL --> SECRETS["secret-scan
+    gitleaks"]
+    VAL --> LICENSE["license
+    fossa / scancode"]
+    VAL --> AI_REVIEW["ai-review
+    code quality"]

-**Steppi-kaavio:**
-```
-checkout → laske versio package.json + git-tageista → output
+    SAST --> PUB
+    SCA --> PUB
+    SECRETS --> PUB
+    LICENSE --> PUB
+    AI_REVIEW --> PUB
+
+    PUB["publish-reports + commit-status"]
+
+    style VAL fill:#2563eb,color:#ffffff
+    style SAST fill:#7c3aed,color:#ffffff
+    style SCA fill:#7c3aed,color:#ffffff
+    style SECRETS fill:#7c3aed,color:#ffffff
+    style LICENSE fill:#7c3aed,color:#ffffff
+    style AI_REVIEW fill:#7c3aed,color:#ffffff
+    style PUB fill:#0891b2,color:#ffffff
+    linkStyle default stroke:#9ca3af,stroke-width:3px
 ```

-### `docker-build-push.yml` — Docker build & push
+| Kategoria | Esimerkki | Kuvaus |
+|-----------|-----------|--------|
+| **SAST** | Semgrep, CodeQL | Staattinen analyysi — bugit ja haavoittuvuudet koodista |
+| **SCA** | Snyk, OWASP Dependency-Check | Riippuvuuksien tunnetut haavoittuvuudet |
+| **Secret scan** | Gitleaks, TruffleHog | API-avaimet, tokenit ja salasanat repossa |
+| **Lisenssit** | FOSSA, ScanCode | Riippuvuuksien lisenssien yhteensopivuus |
+| **AI review** | — | Automaattinen koodikatselmointi |

-**Trigger:** `workflow_call`
+### Error handling

-**Inputs:** `env_json`, `version`
+Providerin julkaisu- ja status-stepit käyttävät `if: always()`-ehtoa,
+jotta raportit ja commit-status päivittyvät myös failaavista ajoista.
+Consumerin omat stepit voivat vapaasti päättää `continue-on-error`- tai
+`if: failure()`-logiikastaan. Provider ei määrittele virheidenkäsittelyä
+consumerin pipelineen.

-**Secrets:** `GITEA_TOKEN`, `DOCKER_USERNAME`, `DOCKER_PASSWORD`
+### Merge-portti

-**Steppi-kaavio:**
+Branch protection -säännössä Giteassa vaaditaan ennen PR:n sulkemista:
+- **Pipeline on ajettu** (`run > 1`, ei "never run" -tila)
+- **Kaikki commit-statukset vihreitä** — validate, testit, laatuportit
+- Jos joku steppi failaa, status asettuu `failure`-tilaan ja PR:n
+  sulkeminen estyy
+
+### Optionaalinen PR-ympäristö (preview app)
+
+Consumer voi halutessaan buildata kontin ja deployata sen väliaikaiseen
+PR-ympäristöön. Tämä on optionaalinen continuation-haara, joka
+aktivoituu ehdolla:
+
+- PR:ssä on tietty label (esim. `preview`)
+- Commit message sisältää triggerisanan (esim. `[preview]`)
+
+**Elinkaari:**
+
+```mermaid
+%%{init: {'theme': 'base', 'flowchart': {'arrowheadScale': 2}}}%%
+flowchart LR
+    QG["quality-gate
+    testit + skannaukset
+    ok"] --> BUILD["build-container
+    tag: pr-42"]
+    BUILD --> DEPLOY["deploy-pr-env
+    väliaikainen ympäristö"]
+
+    DEPLOY --> STATUS["commit-status
+    linkki PR-ympäristöön"]
+
+    PR_CLOSE["PR merged / closed"] --> CLEANUP["cleanup-pr-env
+    tuhoa ympäristö"]
+
+    style QG fill:#059669,color:#ffffff
+    style BUILD fill:#0891b2,color:#ffffff
+    style DEPLOY fill:#7c3aed,color:#ffffff
+    style STATUS fill:#f59e0b,color:#111827
+    style PR_CLOSE fill:#dc2626,color:#ffffff
+    style CLEANUP fill:#dc2626,color:#ffffff
+    linkStyle default stroke:#9ca3af,stroke-width:3px
 ```
-build-push (build + push samassa jobissa, ei levyn kautta) → tag-commit
+
+1. Quality-gate läpäisty (testit + skannaukset ok)
+2. Buildaa kontti, tagi sisältää PR-numeron (`pr-42`)
+3. Deployaa PR-ympäristöön (preview/review app)
+4. Asettaa commit-statuksen linkillä ympäristöön
+5. **PR:n sulkeutuessa** (merge/close): cleanup-job tuhoaa ympäristön
+
+Tämä on **consumerin vastuulla** — provider tarjoaa tarvittavat
+skriptit (`publish-git-pages.sh`, `report-status.sh`), mutta
+trigger-ehto, kontin buildaus ja ympäristön hallinta kuuluvat
+consumerin pipelineen.
+
+---
+
+## `ci-master.yml` — Main-branch build
+
+**Trigger:** `workflow_call` — kutsutaan main-branchiin pushattaessa
+
+**Rooli:** Buildaa artifaktin (kontti, JAR, npm-paketti tms.) ja julkaisee
+sen rekisteriin. Jos sama commit on jo buildattu (version tag on olemassa),
+build skipataan ja siirrytään suoraan test flow'hun.
+
+**Provider-Consumer-malli (ADR 0005):** Provider orkestroi idempotent
+build-logiikan (`isArtifactBuilt`-tarkistus), mutta consumer omistaa
+build-stepit — valitsee työkalut ja artifaktityypin.
+
+### isArtifactBuilt-check
+
+Ennen buildia tarkistetaan, onko tälle commitille jo olemassa versiotagi:
+
+```bash
+TAG=$(git tag --points-at HEAD | grep -E '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$' | head -1)
+if [ -n "$TAG" ]; then
+  echo "artifact_already_built=true" >> $GITHUB_ENV
+  echo "artifact_version=$TAG" >> $GITHUB_ENV
+fi
+```
+
+Jos tagi löytyy, build- ja push-stepit skipataan. Committia vastaan on
+jo olemassa artifakti rekisterissä — uudelleenbuildaus aiheuttaisi
+versiokonflikteja ja tuhlaisi CI-aikaa.
+
+### Steppi-kaavio
+
+```mermaid
+%%{init: {'theme': 'base', 'flowchart': {'arrowheadScale': 2}}}%%
+flowchart TD
+    CHECK{"isArtifactBuilt?
+    git tag --points-at HEAD"}
+
+    CHECK -- "ei" --> QG["quality-gate
+    testit + skannaukset"]
+    QG --> BUILD["build-artifact
+    consumer: docker build /
+    mvn package / npm build"]
+    BUILD --> PUSH["push registry
+    gitea packages /
+    docker registry"]
+    PUSH --> TAG["tag-commit
+    tagittaa commitin
+    versiolla (esim. 1.2.3.${RUN})"]
+
+    CHECK -- "kyllä" --> K8S["continueToTestFlow
+    (future: K8s-testit
+    test plan -mukaan)"]
+    TAG --> K8S
+
+    FAIL("fail") -. "quality-gate
+    ei läpäisty" .-> END
+
+    K8S --> END(["end
+    commit-status"])
+
+    style CHECK fill:#f59e0b,color:#111827
+    style QG fill:#059669,color:#ffffff
+    style BUILD fill:#0891b2,color:#ffffff
+    style PUSH fill:#dc2626,color:#ffffff
+    style TAG fill:#f59e0b,color:#111827
+    style K8S fill:#7c3aed,color:#ffffff
+    style FAIL fill:#dc2626,color:#ffffff
+    style END fill:#2563eb,color:#ffffff
+    linkStyle default stroke:#9ca3af,stroke-width:3px
+```
+
+### Elinkaari
+
+1. **isArtifactBuilt?** — tarkista onko tagi olemassa
+2. **quality-gate** — jos ei tagia, aja `quality-gate.yml` (testit, skannaukset)
+3. **build-artifact** — jos quality-gate läpäisty, buildaa artifakti
+4. **push registry** — julkaise rekisteriin (Gitea Packages, Docker registry, jne.)
+5. **tag-commit** — tagittaa commitin versiolla (esim. `1.2.3.<run_number>`)
+6. **continueToTestFlow** — *(future)* aja K8s-testit test plan -mukaan
+7. **commit-status** — aseta lopullinen status
+
+### Concurrency
+
+```yaml
+concurrency:
+  group: master-${{ github.repository }}
+  cancel-in-progress: false
+```
+
+Vain yksi master-build kerrallaan per repo. Ei cancel-in-progress —
+käynnissä olevan buildin annetaan valmistua.
+
+---
+
+## `deploy.yml` — GitOps-deployment
+
+**Trigger:** `workflow_dispatch` (aina dispatchataan toisesta workflow'sta)
+
+**Elinkaari:**
+
+```
+start → read-yaml → update-value → commit → push → report-cross-repo → end
+```
+
+### Inputs (dispatch-parametrit)
+
+| Parametri | Kuvaus |
+|-----------|--------|
+| `environment` | Ympäristön nimi (korvaa `{.environment}`) |
+| `version` | Uusi konttiversio |
+| `root_commit` | Mikropalvelun commit josta deploy käynnistyi |
+| `root_repo` | Mikropalvelun repo |
+| `root_build_url` | URL mikropalvelun buildiin |
+
+### Mitä deploy tekee
+
+1. Lukee `{projectFolder}/{fileName}` YAML-tiedoston (korvaa `{.environment}` → `environment`)
+2. Päivittää `{property}`-avaimen arvoksi `{version}`
+3. `git add`, `git commit -m "deploy {version} to {environment}"`
+4. `git push origin HEAD:master`
+5. Raportoi statuksen:
+   - Helm-repon committiin: **"from {root_commit}"**, URL → root-build
+   - Mikropalvelun committiin (`root_commit`): **"deployed to {environment}"**, URL → Helm-commit
+6. Palauttaa Helm-commitin hashin (`outputs.commit`)
+
+### Concurrency
+
+```yaml
+concurrency:
+  group: deploy-${{ github.repository }}-${{ inputs.environment }}
+  cancel-in-progress: false
 ```

 ---

-## Consumer-esimerkki (`example-*`)
+## `test.yml` — Test flow -steppi

-### `example-feature.yml` — Feature-haaran CI
+**Trigger:** `workflow_dispatch` (dispatchataan deploy-workflow'n jälkeen)

-**Trigger:** `push` [branches-ignore: main]
+**Elinkaari:**

 ```
-load-config → bats + cucumber → report-summary (always)
+start → version-check → run-tests → push-reports → report-cross-repo → end
 ```

-### `example-main.yml` — Main-haaran CI
+### Inputs (dispatch-parametrit)

-**Trigger:** `push` [branches: main]
+| Parametri | Kuvaus |
+|-----------|--------|
+| `environment` | Testiympäristö |
+| `version` | Testattava konttiversio |
+| `tags` | Cucumber-tagit |
+| `versionApiUrl` | URL version tarkistukseen |
+| `versionCheckScript` | Polku version check -skriptiin |
+| `root_commit` | Mikropalvelun commit |
+| `root_repo` | Mikropalvelun repo |
+| `deploy_commit` | Helm-repon commit (deployattu versio) |
+| `deploy_repo` | Helm-repo |

-```
-load-config → check-version →
-  [artifact exists] → done
-  [no artifact]    → bats + cucumber → report-summary (always) → docker-build-push
+### Version check
+
+Ennen testejä varmistetaan, että ympäristössä pyörii oikea versio:
+
+```yaml
+- name: Check deployed version
+  if: inputs.versionCheckScript || inputs.versionApiUrl
+  run: |
+    if [ -n "${{ inputs.versionCheckScript }}" ]; then
+      bash "${{ inputs.versionCheckScript }}" "${{ inputs.versionApiUrl }}" "${{ inputs.version }}"
+    fi
 ```

-### `example-bats-tests.yml` — Bats unit-testit
+Version check -skripti pollaa Fibonacci-backoffilla — ks. [config-model.md](config-model.md).

-**Trigger:** `workflow_call`
+### Cross-repo-raportointi

-Ajaa Bats-testit Docker-kontissa, generoi coveragen (`bashcov`), julkaisee
-raportit git-pagesiin, asettaa commit-statuksen linkillä raporttiin.
+Testien jälkeen raportoidaan kolmeen committiin:

-### `example-cucumber-tests.yml` — Cucumber hyväksymätestit
+1. Testi-repon oma commit: testin status
+2. Mikropalvelun commit (`root_commit`): "testit OK/epäonnistui"
+3. Helm-repon commit (`deploy_commit`): "testattu v{version}"

-**Trigger:** `workflow_call`
+### Concurrency

-Ajaa Cucumber-testit Node-kontissa, julkaisee raportit git-pagesiin, asettaa
-commit-statuksen linkillä raporttiin.
-
-### `report-summary.yml` — Raporttien koontinäkymä
-
-**Trigger:** `workflow_call` — ajetaan `if: always()` testien jälkeen
-
-**Inputs:** `env_json`, `suites` (space-separated lista suite-nimistä)
-
-Generoi Markdown-taulukon `GITHUB_STEP_SUMMARY`:yn kaikista julkaistuista
-raporteista. Renderöityy HTML:ksi Gitea 1.27+ Summary-välilehdellä.
-Forward-compatibeli — ei haittaa vanhemmilla Gitea-versioilla.
-
---
-
-## Suunnitteilla
-
- `deploy.yml` — GitOps-deployment (dispatch-workflow.sh-pohjainen)
- `test.yml` — Klusteritason test flow
+```yaml
+concurrency:
+  group: test-${{ inputs.environment }}
+  cancel-in-progress: false
+```
@@ -1,6 +1,6 @@
 {
    "name": "gitea-ci-library",
-  "version": "0.2.0",
+    "version": "0.1.0",
    "description": "",
    "main": "cucumber.js",
    "directories": {
Author	SHA1	Message	Date
moilanik	4dcbb11f20	eg CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.8 required Details ci-docker-build Docker build 0.1.8 OK Details ci-docker-push Docker push 0.1.8 OK Details ci-docker-tag Tag 0.1.8 OK Details CI / Build & Push Artifact (push) Successful in 1m27s Details	2026-06-15 13:51:33 +03:00
moilanik	9da134bdaf	1 CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.8 required Details CI / Build & Push Artifact (push) Failing after 27s Details	2026-06-15 13:48:39 +03:00
moilanik	752bbb332f	siivous CI / Load gitea-env.conf to pipeline env (push) Successful in 14s Details ci-check Build version 0.1.8 required Details CI / Build & Push Artifact (push) Failing after 1m2s Details	2026-06-15 13:39:36 +03:00
moilanik	45404dc002	retention temp artifakteille CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Check version FAILED Details CI / Build & Push Artifact (push) Failing after 51s Details	2026-06-15 13:35:14 +03:00
moilanik	5a00763d8f	asgas CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.7 required Details ci-docker-build Docker build 0.1.7 OK Details ci-docker-push Docker push 0.1.7 OK Details ci-docker-tag Tag 0.1.7 OK Details CI / Build & Push Artifact (push) Successful in 1m24s Details	2026-06-15 13:26:08 +03:00
moilanik	4a79ce9d17	sag CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.7 required Details ci-docker-build Docker build 0.1.7 OK Details ci-docker-push Docker push 0.1.7 OK Details CI / Build & Push Artifact (push) Failing after 1m4s Details	2026-06-15 13:21:49 +03:00
moilanik	9d402578bd	siivous CI / Load gitea-env.conf to pipeline env (push) Successful in 14s Details ci-check Build version 0.1.7 required Details ci-docker-build Docker build 0.1.7 OK Details CI / Build & Push Artifact (push) Failing after 53s Details	2026-06-15 13:19:08 +03:00
moilanik	63ce59e604	clean CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.6 required Details ci-docker-build Docker build 0.1.6 OK Details ci-docker-push Docker push 0.1.6 OK Details ci-docker-tag Tag 0.1.6 OK Details CI / Build & Push Artifact (push) Successful in 1m21s Details	2026-06-15 13:13:13 +03:00
moilanik	a566998180	siivous CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.5 required Details ci-docker-build Docker build 0.1.5 OK Details ci-docker-push Docker push 0.1.5 OK Details ci-docker-tag Tag 0.1.5 OK Details CI / Build & Push Artifact (push) Successful in 1m24s Details	2026-06-15 12:43:33 +03:00
moilanik	1239cc5673	siivotaa temp artifactit pois CI / Load gitea-env.conf to pipeline env (push) Successful in 10s Details ci-check Build version 0.1.4 required Details ci-docker-build Docker build 0.1.4 OK Details ci-docker-push Docker push 0.1.4 OK Details ci-docker-tag Tag 0.1.4 OK Details CI / Build & Push Artifact (push) Successful in 1m26s Details	2026-06-15 12:38:44 +03:00
moilanik	20a6099969	kokeillaan meneekö oikeaan paikkaan CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.3 required Details ci-docker-build Docker build 0.1.3 OK Details ci-docker-push Docker push 0.1.3 OK Details ci-docker-tag Tag 0.1.3 OK Details CI / Build & Push Artifact (push) Successful in 1m25s Details	2026-06-15 12:32:04 +03:00
moilanik	c7141fc28f	koodi repon packageksi CI / Load gitea-env.conf to pipeline env (push) Successful in 15s Details ci-check Build version 0.1.2 required Details ci-docker-build Docker build 0.1.2 OK Details ci-docker-push Docker push 0.1.2 OK Details ci-docker-tag Tag 0.1.2 OK Details CI / Build & Push Artifact (push) Successful in 1m34s Details	2026-06-15 12:05:20 +03:00
moilanik	c87e585918	test CI / Load gitea-env.conf to pipeline env (push) Successful in 14s Details ci-check Build version 0.1.1 required Details ci-docker-build Docker build 0.1.1 OK Details ci-docker-push Docker push 0.1.1 OK Details ci-docker-tag Tag 0.1.1 OK Details CI / Build & Push Artifact (push) Successful in 1m22s Details	2026-06-15 11:49:54 +03:00
moilanik	8f4725e23f	docker pat to actions secret in gitea side CI / Load gitea-env.conf to pipeline env (push) Successful in 15s Details ci-check Build version 0.1.0 required Details ci-docker-build Docker build 0.1.0 OK Details ci-docker-push Docker push 0.1.0 OK Details ci-docker-tag Tag 0.1.0 OK Details CI / Build & Push Artifact (push) Successful in 1m56s Details	2026-06-15 11:43:16 +03:00
moilanik	f35c24857f	docker yleiseksi rakenteeltaan CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-docker-build Docker build 0.1.0 OK Details ci-docker-push Docker push 0.1.0 FAILED Details CI / Build & Push Artifact (push) Failing after 1m6s Details	2026-06-15 11:31:09 +03:00
moilanik	c233ef8975	struj CI / Load gitea-env.conf to pipeline env (push) Successful in 14s Details ci-check Build version 0.1.0 required Details ci-docker-build Docker build 0.1.0 OK Details ci-docker-push Docker push 0.1.0 FAILED Details CI / Build & Push Artifact (push) Failing after 1m10s Details	2026-06-15 10:46:06 +03:00
moilanik	f32b345f58	kokeillaan ilman quality gate CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-docker-push Docker push 0.1.0 FAILED Details CI / Build & Push Artifact (push) Failing after 1m4s Details	2026-06-15 10:28:02 +03:00
moilanik	0740dbf815	adrfhhda CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details ci-docker-push Docker push 0.1.0 FAILED Details CI / Build & Push Artifact (push) Failing after 3m28s Details	2026-06-15 09:53:58 +03:00
moilanik	0efd7db43a	asgasr CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details CI / Build & Push Artifact (push) Successful in 15s Details	2026-06-15 09:40:21 +03:00
moilanik	705af709c4	etaerst CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 4m22s Details	2026-06-15 09:29:56 +03:00
moilanik	1d396c8278	runner päivityksessä cucumber testi meni pieleen. korjaus CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m30s Details	2026-06-15 09:20:23 +03:00
moilanik	16b25970ff	päivitettu runner image 1.0.4 -> 1.0.8 CI / Load gitea-env.conf to pipeline env (push) Successful in 2m8s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details CI / Build & Push Artifact (push) Failing after 2m13s Details	2026-06-15 08:50:54 +03:00
moilanik	52601104b0	sdgsf CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 3m45s Details	2026-06-15 08:19:41 +03:00
moilanik	8312cff6ec	asg CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 3m11s Details	2026-06-15 08:07:50 +03:00
moilanik	8c11306f2b	sadg	2026-06-15 08:07:14 +03:00
moilanik	2ae96a5355	asdgas CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Check version FAILED Details CI / Build & Push Artifact (push) Failing after 18s Details	2026-06-15 08:00:59 +03:00
moilanik	fc76234379	fake CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Check version FAILED Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 2m21s Details	2026-06-15 06:42:26 +03:00
moilanik	0fa291f103	asgasg CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Check version FAILED Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 2m28s Details	2026-06-15 06:32:43 +03:00
moilanik	db47775249	build ehto muutos CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m25s Details	2026-06-15 06:13:47 +03:00
moilanik	1be3b5b434	asgre CI / Load gitea-env.conf to pipeline env (push) Successful in 14s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 2m43s Details	2026-06-15 06:07:35 +03:00
moilanik	544ec4afe4	sadg CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m32s Details	2026-06-15 06:03:28 +03:00
moilanik	815c39c6a7	fake CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 2m30s Details	2026-06-15 05:57:08 +03:00
moilanik	ccec73e40a	kiristetään ehtoa! CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Failing after 2m30s Details	2026-06-15 05:49:14 +03:00
moilanik	26394e5a54	build ehto korjattu CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m24s Details	2026-06-15 05:39:10 +03:00
moilanik	8d9bd42f6c	build vaatimus tarkistettu CI / Load gitea-env.conf to pipeline env (push) Successful in 11s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m31s Details	2026-06-15 05:29:51 +03:00
moilanik	69d574955c	pikkasen muutetaan ehtoja CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m33s Details	2026-06-15 05:20:20 +03:00
moilanik	cbd63b7581	google ai kanssa katstottu pipeline CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m34s Details	2026-06-15 05:06:20 +03:00
moilanik	ae84083eae	dsfh CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m35s Details	2026-06-14 14:20:15 +03:00
moilanik	2d3fd96768	argha CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m29s Details	2026-06-14 14:07:13 +03:00
moilanik	95f0aca47e	aedsvg<sDV CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check-running Checking version... Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details CI / Build & Push Artifact (push) Failing after 1m21s Details	2026-06-14 14:01:23 +03:00
moilanik	b6c4d5ae4f	fake CI / Load gitea-env.conf to pipeline env (push) Successful in 15s Details ci-check-running Checking version... Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m31s Details	2026-06-14 13:49:59 +03:00
moilanik	5e011b3993	äpkjoå¨0j CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-bats Bats tests Details ci-build Build complete Details ci-check-running Checking version... Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details CI / Build & Push Artifact (push) Has been cancelled Details	2026-06-14 13:45:12 +03:00
moilanik	5f14554b1f	asg CI / Load gitea-env.conf to pipeline env (push) Successful in 16s Details ci-check-running Checking version... Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m30s Details	2026-06-14 13:39:27 +03:00
moilanik	416939fb82	srghaer CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check-running Checking version... Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m29s Details	2026-06-14 13:25:04 +03:00
moilanik	ccf833d698	öoämj CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-check Build version 0.1.0 required Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m28s Details	2026-06-14 13:11:50 +03:00
moilanik	5848f47c0e	wseg CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-check Check version Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 3m29s Details	2026-06-14 11:08:18 +03:00
moilanik	b32a97ed9b	qwen CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m23s Details	2026-06-14 10:55:18 +03:00
moilanik	e853e22d1d	trigger CI: test build fix CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m31s Details	2026-06-14 10:42:11 +03:00
moilanik	83e35f5324	arghr CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m29s Details	2026-06-14 10:29:10 +03:00
moilanik	95257c17b9	ä',pk'pnå9gv CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m31s Details	2026-06-14 10:12:57 +03:00
moilanik	b51adf3410	adfhadfh CI / Load gitea-env.conf to pipeline env (push) Successful in 13s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m34s Details	2026-06-14 09:55:53 +03:00
moilanik	daa5dc58ed	tuleeko kontti? CI / Load gitea-env.conf to pipeline env (push) Successful in 10s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Build & Push Artifact (push) Successful in 2m34s Details	2026-06-14 09:48:39 +03:00
moilanik	5ac7516672	fix(retention): add retry on Gitea API errors CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Quality Gate (push) Successful in 2m17s Details CI / Build & Push Artifact (push) Has been skipped Details - Retry up to 3 times (2 retries) on non-200/non-404 responses - 10 second delay between retries - Fail-safe: keep report if all retries fail	2026-06-14 09:17:09 +03:00
moilanik	622e8acdc5	fix(retention): fail-safe on Gitea API errors - Keep reports when Gitea API returns non-200/non-404 status - Only delete on actual 404 (branch truly doesn't exist) - Log warning for API errors to aid debugging	2026-06-14 09:14:52 +03:00
moilanik	6e26281fea	fix: add missing GITEA_TOKEN auth to tags API call in check job CI / Load gitea-env.conf to pipeline env (push) Successful in 12s Details CI / Build & Push Artifact (push) Has been skipped Details ci-cucumber Cucumber tests Details ci-bats Bats tests Details ci-build Build complete Details CI / Quality Gate (push) Successful in 2m14s Details	2026-06-14 08:56:54 +03:00