Merge branch 'main' of gitea.com:gitea/act_runner into act-runner-actions-oss-act

Merge branch 'act-runner-actions-oss-act' of gitea.com:gitea/act_runner into act-runner-actions-oss-act
Move logging to another file
2026-04-24 21:00:27 +08:00 · 2026-02-22 20:26:32 +01:00 · 2026-02-22 17:34:49 +01:00 · 2026-02-22 17:34:18 +01:00 · 2026-02-22 17:28:48 +01:00 · 2026-02-22 15:07:57 +00:00
25 changed files with 417 additions and 1541 deletions
--- a/.gitea/workflows/release-tag.yml
+++ b/.gitea/workflows/release-tag.yml
@@ -39,15 +39,6 @@ jobs:
          GPG_FINGERPRINT: ${{ steps.import_gpg.outputs.fingerprint }}
  release-image:
    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        variant:
-          - target: basic
-            tag_suffix: ""
-          - target: dind
-            tag_suffix: "-dind"
-          - target: dind-rootless
-            tag_suffix: "-dind-rootless"
    container:
      image: catthehacker/ubuntu:act-latest
    env:
@@ -71,33 +62,50 @@ jobs:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

-      - name: Repo Meta
-        id: repo_meta
+      - name: Get Meta
+        id: meta
        run: |
          echo REPO_NAME=$(echo ${GITHUB_REPOSITORY} | awk -F"/" '{print $2}') >> $GITHUB_OUTPUT
-
-      - name: "Docker meta"
-        id: docker_meta
-        uses: https://github.com/docker/metadata-action@v5
-        with:
-          images: |
-            ${{ env.DOCKER_ORG }}/${{ steps.repo_meta.outputs.REPO_NAME }}
-          tags: |
-            type=semver,pattern={{major}}.{{minor}}.{{patch}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=semver,pattern={{major}}
-          flavor: |
-            latest=true
-            suffix=${{ matrix.variant.tag_suffix }},onlatest=true
+          echo REPO_VERSION=${GITHUB_REF_NAME#v} >> $GITHUB_OUTPUT

      - name: Build and push
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./Dockerfile
-          target: ${{ matrix.variant.target }}
+          target: basic
          platforms: |
            linux/amd64
            linux/arm64
          push: true
-          tags: ${{ steps.docker_meta.outputs.tags }}
+          tags: |
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}
+
+      - name: Build and push dind
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          target: dind
+          platforms: |
+            linux/amd64
+            linux/arm64
+          push: true
+          tags: |
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}-dind
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}-dind
+
+      - name: Build and push dind-rootless
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          target: dind-rootless
+          platforms: |
+            linux/amd64
+            linux/arm64
+          push: true
+          tags: |
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}-dind-rootless
+            ${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}-dind-rootless
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 .env
 .runner
 coverage.txt
+/gitea-vet
 /config.yaml

 # Jetbrains
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -13,7 +13,6 @@ linters:
    - forbidigo
    - gocheckcompilerdirectives
    - gocritic
-    - goheader
    - govet
    - ineffassign
    - mirror
@@ -86,11 +85,6 @@ linters:
      enable:
        - nilness
        - unusedwrite
-    goheader:
-      values:
-        regexp:
-          HEADER: 'Copyright \d{4} The Gitea Authors\. All rights reserved\.(\nCopyright [^\n]+)*\nSPDX-License-Identifier: MIT'
-      template: '{{ HEADER }}'
  exclusions:
    generated: lax
    presets:
@@ -107,16 +101,9 @@ issues:
  max-same-issues: 0
 formatters:
  enable:
-    - gci
+    - gofmt
    - gofumpt
  settings:
-    gci:
-      custom-order: true
-      sections:
-        - standard
-        - prefix(gitea.com/gitea/act_runner)
-        - blank
-        - default
    gofumpt:
      extra-rules: true
  exclusions:
--- a/32
+++ b/32
@@ -1,5 +1,6 @@
 DIST := dist
 EXECUTABLE := act_runner
+GOFMT ?= gofumpt -l
 DIST_DIRS := $(DIST)/binaries $(DIST)/release
 GO ?= go
 SHASUM ?= shasum -a 256
@@ -11,6 +12,7 @@ GXZ_PAGAGE ?= github.com/ulikunitz/xz/cmd/gxz@v0.5.10
 LINUX_ARCHS ?= linux/amd64,linux/arm64
 DARWIN_ARCHS ?= darwin-12/amd64,darwin-12/arm64
 WINDOWS_ARCHS ?= windows/amd64
+GO_FMT_FILES := $(shell find . -type f -name "*.go" ! -name "generated.*")
 GOFILES := $(shell find . -type f -name "*.go" -o -name "go.mod" ! -name "generated.*")

 DOCKER_IMAGE ?= gitea/act_runner
@@ -18,7 +20,7 @@ DOCKER_TAG ?= nightly
 DOCKER_REF := $(DOCKER_IMAGE):$(DOCKER_TAG)
 DOCKER_ROOTLESS_REF := $(DOCKER_IMAGE):$(DOCKER_TAG)-dind-rootless

-GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.11.4
+GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.10.1
 GOVULNCHECK_PACKAGE ?= golang.org/x/vuln/cmd/govulncheck@v1

 ifneq ($(shell uname), Darwin)
@@ -66,14 +68,19 @@ else
 	endif
 endif

+GO_PACKAGES_TO_VET ?= $(filter-out gitea.com/gitea/act_runner/internal/pkg/client/mocks,$(shell $(GO) list ./...))
+
+
 TAGS ?=
 LDFLAGS ?= -X "gitea.com/gitea/act_runner/internal/pkg/ver.version=v$(RELASE_VERSION)"

 all: build

-.PHONY: fmt
 fmt:
-	$(GO) run $(GOLANGCI_LINT_PACKAGE) fmt
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt@latest; \
+	fi
+	$(GOFMT) -w $(GO_FMT_FILES)

 .PHONY: go-check
 go-check:
@@ -86,20 +93,23 @@ go-check:
 	fi

 .PHONY: fmt-check
-fmt-check: fmt
-	@diff=$$(git diff --color=always); \
+fmt-check:
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt@latest; \
+	fi
+	@diff=$$($(GOFMT) -d $(GO_FMT_FILES)); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make fmt' and commit the result:"; \
-		printf "%s" "$${diff}"; \
+		echo "$${diff}"; \
 		exit 1; \
-	fi
+	fi;

 .PHONY: deps-tools
 deps-tools: ## install tool dependencies
 	$(GO) install $(GOVULNCHECK_PACKAGE)

 .PHONY: lint
-lint: lint-go
+lint: lint-go vet

 .PHONY: lint-go
 lint-go: ## lint go files
@@ -129,6 +139,12 @@ tidy-check: tidy
 test: fmt-check security-check
 	@$(GO) test -race -v -cover -coverprofile coverage.txt ./... && echo "\n==>\033[32m Ok\033[m\n" || exit 1

+.PHONY: vet
+vet:
+	@echo "Running go vet..."
+	@$(GO) build code.gitea.io/gitea-vet
+	@$(GO) vet -vettool=gitea-vet $(GO_PACKAGES_TO_VET)
+
 install: $(GOFILES)
 	$(GO) install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'

--- a/build.go
+++ b/build.go
@@ -0,0 +1,11 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//go:build vendor
+
+package main
+
+import (
+	// for vet
+	_ "code.gitea.io/gitea-vet"
+)
--- a/go.mod
+++ b/go.mod
@@ -4,62 +4,58 @@ go 1.26.0

 require (
 	code.gitea.io/actions-proto-go v0.4.1
+	code.gitea.io/gitea-vet v0.2.3
 	connectrpc.com/connect v1.19.1
+	github.com/actions-oss/act-cli v0.0.0 // will be replaced
 	github.com/avast/retry-go/v4 v4.7.0
-	github.com/docker/docker v25.0.13+incompatible
+	github.com/docker/docker v28.5.1+incompatible
 	github.com/joho/godotenv v1.5.1
 	github.com/mattn/go-isatty v0.0.20
-	github.com/nektos/act v0.0.0 // will be replaced
 	github.com/sirupsen/logrus v1.9.4
 	github.com/spf13/cobra v1.10.2
 	github.com/stretchr/testify v1.11.1
-	go.yaml.in/yaml/v4 v4.0.0-rc.3
 	golang.org/x/term v0.40.0
-	golang.org/x/time v0.14.0 // indirect
+	golang.org/x/time v0.14.0
 	google.golang.org/protobuf v1.36.11
 	gopkg.in/yaml.v3 v3.0.1
 	gotest.tools/v3 v3.5.2
 )

-require github.com/prometheus/client_golang v1.23.2
+require go.yaml.in/yaml/v4 v4.0.0-rc.3

 require (
 	cyphar.com/go-pathrs v0.2.3 // indirect
 	dario.cat/mergo v1.0.2 // indirect
-	github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 // indirect
 	github.com/Masterminds/semver v1.5.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/bmatcuk/doublestar/v4 v4.10.0 // indirect
+	github.com/avast/retry-go v3.0.0+incompatible // indirect
+	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
 	github.com/cloudflare/circl v1.6.3 // indirect
-	github.com/containerd/containerd v1.7.29 // indirect
+	github.com/containerd/errdefs v1.0.0 // indirect
+	github.com/containerd/errdefs/pkg v0.3.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
 	github.com/creack/pty v1.1.24 // indirect
 	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/distribution/reference v0.6.0 // indirect
-	github.com/docker/cli v25.0.3+incompatible // indirect
-	github.com/docker/distribution v2.8.3+incompatible // indirect
+	github.com/docker/cli v28.5.1+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.9.5 // indirect
 	github.com/docker/go-connections v0.6.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/fatih/color v1.18.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.7.0 // indirect
 	github.com/go-git/go-git/v5 v5.16.5 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/gobwas/glob v0.2.3 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/imdario/mergo v0.3.16 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/julienschmidt/httprouter v1.3.0 // indirect
@@ -67,28 +63,19 @@ require (
 	github.com/kevinburke/ssh_config v1.6.0 // indirect
 	github.com/klauspost/compress v1.18.4 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-runewidth v0.0.20 // indirect
-	github.com/mattn/go-shellwords v1.0.12 // indirect
-	github.com/mitchellh/mapstructure v1.1.2 // indirect
-	github.com/moby/buildkit v0.13.2 // indirect
+	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/moby/go-archive v0.1.0 // indirect
 	github.com/moby/patternmatcher v0.6.0 // indirect
 	github.com/moby/sys/sequential v0.6.0 // indirect
 	github.com/moby/sys/user v0.4.0 // indirect
 	github.com/moby/sys/userns v0.1.0 // indirect
 	github.com/moby/term v0.5.2 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
 	github.com/opencontainers/image-spec v1.1.1 // indirect
 	github.com/opencontainers/selinux v1.13.1 // indirect
 	github.com/pjbgf/sha1cd v0.5.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.66.1 // indirect
-	github.com/prometheus/procfs v0.16.1 // indirect
-	github.com/rhysd/actionlint v1.7.11 // indirect
-	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/skeema/knownhosts v1.3.2 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
@@ -102,20 +89,19 @@ require (
 	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0 // indirect
 	go.opentelemetry.io/otel v1.40.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 // indirect
 	go.opentelemetry.io/otel/metric v1.40.0 // indirect
 	go.opentelemetry.io/otel/trace v1.40.0 // indirect
-	go.yaml.in/yaml/v2 v2.4.2 // indirect
+	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
 	golang.org/x/crypto v0.48.0 // indirect
 	golang.org/x/net v0.50.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect
-	google.golang.org/grpc v1.67.0 // indirect
+	golang.org/x/tools v0.42.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

-replace github.com/nektos/act => gitea.com/gitea/act v0.261.10
+replace github.com/actions-oss/act-cli => gitea.com/actions-oss/act-cli v0.4.2-0.20260220200604-40ee0f3ef6fc

 // Remove after github.com/docker/distribution is updated to support distribution/reference v0.6.0
 // (pulled in via moby/buildkit, breaks on undefined: reference.SplitHostname)
--- a/go.sum
+++ b/go.sum
@@ -1,13 +1,15 @@
 code.gitea.io/actions-proto-go v0.4.1 h1:l0EYhjsgpUe/1VABo2eK7zcoNX2W44WOnb0MSLrKfls=
 code.gitea.io/actions-proto-go v0.4.1/go.mod h1:mn7Wkqz6JbnTOHQpot3yDeHx+O5C9EGhMEE+htvHBas=
+code.gitea.io/gitea-vet v0.2.3 h1:gdFmm6WOTM65rE8FUBTRzeQZYzXePKSSB1+r574hWwI=
+code.gitea.io/gitea-vet v0.2.3/go.mod h1:zcNbT/aJEmivCAhfmkHOlT645KNOf9W2KnkLgFjGGfE=
 connectrpc.com/connect v1.19.1 h1:R5M57z05+90EfEvCY1b7hBxDVOUl45PrtXtAV2fOC14=
 connectrpc.com/connect v1.19.1/go.mod h1:tN20fjdGlewnSFeZxLKb0xwIZ6ozc3OQs2hTXy4du9w=
 cyphar.com/go-pathrs v0.2.3 h1:0pH8gep37wB0BgaXrEaN1OtZhUMeS7VvaejSr6i822o=
 cyphar.com/go-pathrs v0.2.3/go.mod h1:y8f1EMG7r+hCuFf/rXsKqMJrJAUoADZGNh5/vZPKcGc=
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
-gitea.com/gitea/act v0.261.10 h1:ndwbtuMXXz1dpYF2iwY1/PkgKNETo4jmPXfinTZt8cs=
-gitea.com/gitea/act v0.261.10/go.mod h1:oIkqQHvU0lfuIWwcpqa4FmU+t3prA89tgkuHUTsrI2c=
+gitea.com/actions-oss/act-cli v0.4.2-0.20260220200604-40ee0f3ef6fc h1:KXg17X1FZhnUM4J0bVG3gVS6jQCtkR6U5aV2ch0tJYA=
+gitea.com/actions-oss/act-cli v0.4.2-0.20260220200604-40ee0f3ef6fc/go.mod h1:tl2dPJQRui7za899nfJIhPqP3a8ii+ySEvzL18mjC0U=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
@@ -17,30 +19,26 @@ github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF0
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-github.com/Microsoft/hcsshim v0.11.7 h1:vl/nj3Bar/CvJSYo7gIQPyRWc9f3c6IeSNavBTSZNZQ=
-github.com/Microsoft/hcsshim v0.11.7/go.mod h1:MV8xMfmECjl5HdO7U/3/hFVnkmSBjAjmA09d4bExKcU=
 github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=
 github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
+github.com/avast/retry-go v3.0.0+incompatible h1:4SOWQ7Qs+oroOTQOYnAHqelpCO0biHSxpiH9JdtuBj0=
+github.com/avast/retry-go v3.0.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY=
 github.com/avast/retry-go/v4 v4.7.0 h1:yjDs35SlGvKwRNSykujfjdMxMhMQQM0TnIjJaHB+Zio=
 github.com/avast/retry-go/v4 v4.7.0/go.mod h1:ZMPDa3sY2bKgpLtap9JRUgk2yTAba7cgiFhqxY2Sg6Q=
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
-github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bmatcuk/doublestar/v4 v4.10.0 h1:zU9WiOla1YA122oLM6i4EXvGW62DvKZVxIe6TYWexEs=
-github.com/bmatcuk/doublestar/v4 v4.10.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
 github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
-github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
 github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8=
 github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
-github.com/containerd/containerd v1.7.29 h1:90fWABQsaN9mJhGkoVnuzEY+o1XDPbg9BTC9QTAHnuE=
-github.com/containerd/containerd v1.7.29/go.mod h1:azUkWcOvHrWvaiUjSQH0fjzuHIwSPg1WL5PshGP4Szs=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
+github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
 github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
 github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
@@ -53,12 +51,10 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/distribution/reference v0.5.0 h1:/FUIFXtfc/x2gpa5/VGfiGLuOIdYa1t65IKK2OFGvA0=
 github.com/distribution/reference v0.5.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
-github.com/docker/cli v25.0.3+incompatible h1:KLeNs7zws74oFuVhgZQ5ONGZiXUUdgsdy6/EsX/6284=
-github.com/docker/cli v25.0.3+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
-github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
-github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
-github.com/docker/docker v25.0.13+incompatible h1:YeBrkUd3q0ZoRDNoEzuopwCLU+uD8GZahDHwBdsTnkU=
-github.com/docker/docker v25.0.13+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/cli v28.5.1+incompatible h1:ESutzBALAD6qyCLqbQSEf1a/U8Ybms5agw59yGVc+yY=
+github.com/docker/cli v28.5.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/docker v28.5.1+incompatible h1:Bm8DchhSD2J6PsFzxC35TZo4TLGR2PdW/E69rU45NhM=
+github.com/docker/docker v28.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/docker-credential-helpers v0.9.5 h1:EFNN8DHvaiK8zVqFA2DT6BjXE0GzfLOZ38ggPTKePkY=
 github.com/docker/docker-credential-helpers v0.9.5/go.mod h1:v1S+hepowrQXITkEfw6o4+BMbGot02wiKpzWhGUZK6c=
 github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94=
@@ -69,8 +65,6 @@ github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o
 github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
@@ -88,10 +82,10 @@ github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
-github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
+github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
 github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
@@ -102,8 +96,6 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 h1:YBftPWNWd4WwGqtY2yeZL2ef8rHAxPBD8KFhJpmcqms=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg=
-github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4=
-github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
@@ -116,8 +108,6 @@ github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNU
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kevinburke/ssh_config v1.6.0 h1:J1FBfmuVosPHf5GRdltRLhPJtJpTlMdKTBjRgTaQBFY=
 github.com/kevinburke/ssh_config v1.6.0/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
-github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.18.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
 github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
@@ -129,22 +119,16 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.20 h1:WcT52H91ZUAwy8+HUkdM3THM6gXqXuLJi9O3rjcQQaQ=
-github.com/mattn/go-runewidth v0.0.20/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
-github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
-github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
-github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/moby/buildkit v0.13.2 h1:nXNszM4qD9E7QtG7bFWPnDI1teUQFQglBzon/IU3SzI=
-github.com/moby/buildkit v0.13.2/go.mod h1:2cyVOv9NoHM7arphK9ZfHIWKn9YVZRFd1wXB8kKmEzY=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ=
+github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo=
 github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
 github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
+github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw=
+github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs=
 github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU=
 github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko=
 github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs=
@@ -155,8 +139,6 @@ github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=
 github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
 github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
@@ -171,18 +153,6 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
-github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
-github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
-github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
-github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
-github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
-github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
-github.com/rhysd/actionlint v1.7.11 h1:m+aSuCpCIClS8X02xMG4Z8s87fCHPsAtYkAoWGQZgEE=
-github.com/rhysd/actionlint v1.7.11/go.mod h1:8n50YougV9+50niD7oxgDTZ1KbN/ZnKiQ2xpLFeVhsI=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -222,8 +192,7 @@ github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHo
 github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
 github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.etcd.io/bbolt v1.3.8/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
 go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
 go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
@@ -236,8 +205,8 @@ go.opentelemetry.io/otel v1.40.0 h1:oA5YeOcpRTXq6NN7frwmwFR0Cn3RhTVZvXsP4duvCms=
 go.opentelemetry.io/otel v1.40.0/go.mod h1:IMb+uXZUKkMXdPddhwAHm6UfOwJyh4ct1ybIlV14J0g=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0 h1:digkEZCJWobwBqMwC0cwCq8/wkkRy/OowZg5OArWZrM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0/go.mod h1:/OpE/y70qVkndM0TrxT4KBoN3RsFZP0QaofcfYrj76I=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0 h1:j9+03ymgYhPKmeXGk5Zu+cIZOlVzd9Zv7QIiyItjFBU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0/go.mod h1:Y5+XiUG4Emn1hTfciPzGPJaSI+RpDts6BnCIir0SLqk=
 go.opentelemetry.io/otel/metric v1.40.0 h1:rcZe317KPftE2rstWIBitCdVp89A2HqjkxR3c11+p9g=
 go.opentelemetry.io/otel/metric v1.40.0/go.mod h1:ib/crwQH7N3r5kfiBZQbwrTge743UDc7DTFVZrrXnqc=
 go.opentelemetry.io/otel/sdk v1.40.0 h1:KHW/jUzgo6wsPh9At46+h4upjtccTmuZCFAc9OJ71f8=
@@ -248,39 +217,32 @@ go.opentelemetry.io/otel/trace v1.40.0 h1:WA4etStDttCSYuhwvEa8OP8I5EWu24lkOzp+ZY
 go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqQ5RgdEJcawiA=
 go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I=
 go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
-go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
-go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 go.yaml.in/yaml/v4 v4.0.0-rc.3 h1:3h1fjsh1CTAPjW7q/EMe+C8shx5d8ctzZTrLcs/j8Go=
 go.yaml.in/yaml/v4 v4.0.0-rc.3/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
 golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 h1:e66Fs6Z+fZTbFBAxKfP3PALWBtpfqks2bwGcexMxgtk=
+golang.org/x/exp v0.0.0-20240909161429-701f63a606c0/go.mod h1:2TbTHSBQa924w8M6Xs1QcRcFwyucIwBGpK1p2f1YFFY=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
+golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
 golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -295,7 +257,6 @@ golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9sn
 golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
 golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
 golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
@@ -303,13 +264,12 @@ golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
 golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20200325010219-a49f79bcc224/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
+golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto v0.0.0-20231211222908-989df2bf70f3 h1:1hfbdAfFbkmpg41000wDVqr7jUpK/Yo+LPnIxxGzmkg=
 google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 h1:wKguEg1hsxI2/L3hUYrpo1RVi48K+uTyzKqprwLXsb8=
 google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
@@ -325,7 +285,6 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/internal/app/cmd/cache-server.go
+++ b/internal/app/cmd/cache-server.go
@@ -10,7 +10,7 @@ import (

 	"gitea.com/gitea/act_runner/internal/pkg/config"

-	"github.com/nektos/act/pkg/artifactcache"
+	"github.com/actions-oss/act-cli/pkg/artifactcache"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
--- a/internal/app/cmd/cmd.go
+++ b/internal/app/cmd/cmd.go
@@ -8,10 +8,10 @@ import (
 	"fmt"
 	"os"

+	"github.com/spf13/cobra"
+
 	"gitea.com/gitea/act_runner/internal/pkg/config"
 	"gitea.com/gitea/act_runner/internal/pkg/ver"
-
-	"github.com/spf13/cobra"
 )

 func Execute(ctx context.Context) {
--- a/internal/app/cmd/daemon.go
+++ b/internal/app/cmd/daemon.go
@@ -16,19 +16,18 @@ import (
 	"strings"
 	"time"

+	"connectrpc.com/connect"
+	"github.com/mattn/go-isatty"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
 	"gitea.com/gitea/act_runner/internal/app/poll"
 	"gitea.com/gitea/act_runner/internal/app/run"
 	"gitea.com/gitea/act_runner/internal/pkg/client"
 	"gitea.com/gitea/act_runner/internal/pkg/config"
 	"gitea.com/gitea/act_runner/internal/pkg/envcheck"
 	"gitea.com/gitea/act_runner/internal/pkg/labels"
-	"gitea.com/gitea/act_runner/internal/pkg/metrics"
 	"gitea.com/gitea/act_runner/internal/pkg/ver"
-
-	"connectrpc.com/connect"
-	"github.com/mattn/go-isatty"
-	log "github.com/sirupsen/logrus"
-	"github.com/spf13/cobra"
 )

 func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) func(cmd *cobra.Command, args []string) error {
@@ -150,15 +149,6 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 				resp.Msg.Runner.Name, resp.Msg.Runner.Version, resp.Msg.Runner.Labels)
 		}

-		if cfg.Metrics.Enabled {
-			metrics.Init()
-			metrics.RunnerInfo.WithLabelValues(ver.Version(), resp.Msg.Runner.Name).Set(1)
-			metrics.RunnerCapacity.Set(float64(cfg.Runner.Capacity))
-			metrics.RegisterUptimeFunc(time.Now())
-			metrics.RegisterRunningJobsFunc(runner.RunningCount, cfg.Runner.Capacity)
-			metrics.StartServer(ctx, cfg.Metrics.Addr)
-		}
-
 		poller := poll.New(cfg, cli, runner)

 		if daemArgs.Once || reg.Ephemeral {
--- a/internal/app/cmd/exec.go
+++ b/internal/app/cmd/exec.go
@@ -13,15 +13,16 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"time"

+	"gitea.com/gitea/act_runner/internal/app/run"
+	"github.com/actions-oss/act-cli/pkg/artifactcache"
+	"github.com/actions-oss/act-cli/pkg/artifacts"
+	"github.com/actions-oss/act-cli/pkg/common"
+	"github.com/actions-oss/act-cli/pkg/model"
+	"github.com/actions-oss/act-cli/pkg/runner"
+	"github.com/actions-oss/act-cli/pkg/schema"
 	"github.com/docker/docker/api/types/container"
 	"github.com/joho/godotenv"
-	"github.com/nektos/act/pkg/artifactcache"
-	"github.com/nektos/act/pkg/artifacts"
-	"github.com/nektos/act/pkg/common"
-	"github.com/nektos/act/pkg/model"
-	"github.com/nektos/act/pkg/runner"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"golang.org/x/term"
@@ -312,7 +313,12 @@ func runExecList(planner model.WorkflowPlanner, execArgs *executeArgs) error {

 func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command, args []string) error {
 	return func(cmd *cobra.Command, args []string) error {
-		planner, err := model.NewWorkflowPlanner(execArgs.WorkflowsPath(), execArgs.noWorkflowRecurse)
+		planner, err := model.NewWorkflowPlanner(execArgs.WorkflowsPath(), model.PlannerConfig{
+			Recursive: !execArgs.noWorkflowRecurse,
+			Workflow: model.WorkflowConfig{
+				Schema: schema.GetGiteaWorkflowSchema(),
+			},
+		})
 		if err != nil {
 			return err
 		}
@@ -361,10 +367,11 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 			}
 		}

-		maxLifetime := 3 * time.Hour
-		if deadline, ok := ctx.Deadline(); ok {
-			maxLifetime = time.Until(deadline)
-		}
+		// TODO GITEA
+		// maxLifetime := 3 * time.Hour
+		// if deadline, ok := ctx.Deadline(); ok {
+		// 	maxLifetime = time.Until(deadline)
+		// }

 		// init a cache server
 		handler, err := artifactcache.StartHandler("", "", 0, log.StandardLogger().WithField("module", "cache_request"))
@@ -421,14 +428,16 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 			NoSkipCheckout:        execArgs.noSkipCheckout,
 			// PresetGitHubContext:   preset,
 			// EventJSON:             string(eventJSON),
-			ContainerNamePrefix:   "GITEA-ACTIONS-TASK-" + eventName,
-			ContainerMaxLifetime:  maxLifetime,
-			ContainerNetworkMode:  container.NetworkMode(execArgs.network),
-			DefaultActionInstance: execArgs.defaultActionsURL,
-			PlatformPicker: func(_ []string) string {
-				return execArgs.image
-			},
-			ValidVolumes: []string{"**"}, // All volumes are allowed for `exec` command
+			// TODO GITEA
+			// ContainerNamePrefix:   "GITEA-ACTIONS-TASK-" + eventName,
+			// ContainerMaxLifetime:  maxLifetime,
+			ContainerNetworkMode: container.NetworkMode(execArgs.network),
+			// TODO GITEA
+			// DefaultActionInstance: execArgs.defaultActionsURL,
+			// PlatformPicker: func(_ []string) string {
+			// 	return execArgs.image
+			// },
+			// ValidVolumes: []string{"**"}, // All volumes are allowed for `exec` command
 		}

 		config.Env["ACT_EXEC"] = "true"
@@ -439,10 +448,8 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 			config.Token = t
 		}

-		if !execArgs.debug {
-			logLevel := log.InfoLevel
-			config.JobLoggerLevel = &logLevel
-		}
+		// TODO GITEA
+		ctx = runner.WithJobLoggerFactory(ctx, &run.JobLoggerFactoryWithInfoLevel{})

 		r, err := runner.New(config)
 		if err != nil {
--- a/internal/app/cmd/register.go
+++ b/internal/app/cmd/register.go
@@ -14,17 +14,17 @@ import (
 	"strings"
 	"time"

-	"gitea.com/gitea/act_runner/internal/pkg/client"
-	"gitea.com/gitea/act_runner/internal/pkg/config"
-	"gitea.com/gitea/act_runner/internal/pkg/labels"
-	"gitea.com/gitea/act_runner/internal/pkg/ver"
-
 	pingv1 "code.gitea.io/actions-proto-go/ping/v1"
 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
 	"connectrpc.com/connect"
 	"github.com/mattn/go-isatty"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+
+	"gitea.com/gitea/act_runner/internal/pkg/client"
+	"gitea.com/gitea/act_runner/internal/pkg/config"
+	"gitea.com/gitea/act_runner/internal/pkg/labels"
+	"gitea.com/gitea/act_runner/internal/pkg/ver"
 )

 // runRegister registers a runner to the server
--- a/internal/app/poll/poller.go
+++ b/internal/app/poll/poller.go
@@ -7,29 +7,22 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math/rand/v2"
 	"sync"
 	"sync/atomic"
-	"time"
-
-	"gitea.com/gitea/act_runner/internal/pkg/client"
-	"gitea.com/gitea/act_runner/internal/pkg/config"
-	"gitea.com/gitea/act_runner/internal/pkg/metrics"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
 	"connectrpc.com/connect"
 	log "github.com/sirupsen/logrus"
-)
+	"golang.org/x/time/rate"

-// TaskRunner abstracts task execution so the poller can be tested
-// without a real runner.
-type TaskRunner interface {
-	Run(ctx context.Context, task *runnerv1.Task) error
-}
+	"gitea.com/gitea/act_runner/internal/app/run"
+	"gitea.com/gitea/act_runner/internal/pkg/client"
+	"gitea.com/gitea/act_runner/internal/pkg/config"
+)

 type Poller struct {
 	client       client.Client
-	runner       TaskRunner
+	runner       *run.Runner
 	cfg          *config.Config
 	tasksVersion atomic.Int64 // tasksVersion used to store the version of the last task fetched from the Gitea.

@@ -42,19 +35,7 @@ type Poller struct {
 	done chan struct{}
 }

-// workerState holds the single poller's backoff state. Consecutive empty or
-// error responses drive exponential backoff; a successful task fetch resets
-// both counters so the next poll fires immediately.
-type workerState struct {
-	consecutiveEmpty  int64
-	consecutiveErrors int64
-	// lastBackoff is the last interval reported to the PollBackoffSeconds gauge;
-	// used to suppress redundant no-op Set calls when the backoff plateaus
-	// (e.g. at FetchIntervalMax).
-	lastBackoff time.Duration
-}
-
-func New(cfg *config.Config, client client.Client, runner TaskRunner) *Poller {
+func New(cfg *config.Config, client client.Client, runner *run.Runner) *Poller {
 	pollingCtx, shutdownPolling := context.WithCancel(context.Background())

 	jobsCtx, shutdownJobs := context.WithCancel(context.Background())
@@ -77,57 +58,25 @@ func New(cfg *config.Config, client client.Client, runner TaskRunner) *Poller {
 }

 func (p *Poller) Poll() {
-	sem := make(chan struct{}, p.cfg.Runner.Capacity)
+	limiter := rate.NewLimiter(rate.Every(p.cfg.Runner.FetchInterval), 1)
 	wg := &sync.WaitGroup{}
-	s := &workerState{}
-
-	defer func() {
-		wg.Wait()
-		close(p.done)
-	}()
-
-	for {
-		select {
-		case sem <- struct{}{}:
-		case <-p.pollingCtx.Done():
-			return
-		}
-
-		task, ok := p.fetchTask(p.pollingCtx, s)
-		if !ok {
-			<-sem
-			if !p.waitBackoff(s) {
-				return
-			}
-			continue
-		}
-
-		s.resetBackoff()
-
+	for i := 0; i < p.cfg.Runner.Capacity; i++ {
 		wg.Add(1)
-		go func(t *runnerv1.Task) {
-			defer wg.Done()
-			defer func() { <-sem }()
-			p.runTaskWithRecover(p.jobsCtx, t)
-		}(task)
+		go p.poll(wg, limiter)
 	}
+	wg.Wait()
+
+	// signal that we shutdown
+	close(p.done)
 }

 func (p *Poller) PollOnce() {
-	defer close(p.done)
-	s := &workerState{}
-	for {
-		task, ok := p.fetchTask(p.pollingCtx, s)
-		if !ok {
-			if !p.waitBackoff(s) {
-				return
-			}
-			continue
-		}
-		s.resetBackoff()
-		p.runTaskWithRecover(p.jobsCtx, task)
-		return
-	}
+	limiter := rate.NewLimiter(rate.Every(p.cfg.Runner.FetchInterval), 1)
+
+	p.pollOnce(limiter)
+
+	// signal that we're done
+	close(p.done)
 }

 func (p *Poller) Shutdown(ctx context.Context) error {
@@ -140,13 +89,13 @@ func (p *Poller) Shutdown(ctx context.Context) error {

 	// our timeout for shutting down ran out
 	case <-ctx.Done():
-		// Both the timeout and the graceful shutdown may fire
-		// simultaneously. Do a non-blocking check to avoid forcing
-		// a shutdown when graceful already completed.
-		select {
-		case <-p.done:
+		// when both the timeout fires and the graceful shutdown
+		// completed succsfully, this branch of the select may
+		// fire. Do a non-blocking check here against the graceful
+		// shutdown status to avoid sending an error if we don't need to.
+		_, ok := <-p.done
+		if !ok {
 			return nil
-		default:
 		}

 		// force a shutdown of all running jobs
@@ -159,60 +108,36 @@ func (p *Poller) Shutdown(ctx context.Context) error {
 	}
 }

-func (s *workerState) resetBackoff() {
-	s.consecutiveEmpty = 0
-	s.consecutiveErrors = 0
-	s.lastBackoff = 0
-}
+func (p *Poller) poll(wg *sync.WaitGroup, limiter *rate.Limiter) {
+	defer wg.Done()
+	for {
+		p.pollOnce(limiter)

-// waitBackoff sleeps for the current backoff interval (with jitter).
-// Returns false if the polling context was cancelled during the wait.
-func (p *Poller) waitBackoff(s *workerState) bool {
-	base := p.calculateInterval(s)
-	if base != s.lastBackoff {
-		metrics.PollBackoffSeconds.Set(base.Seconds())
-		s.lastBackoff = base
-	}
-	timer := time.NewTimer(addJitter(base))
-	select {
-	case <-timer.C:
-		return true
-	case <-p.pollingCtx.Done():
-		timer.Stop()
-		return false
+		select {
+		case <-p.pollingCtx.Done():
+			return
+		default:
+			continue
+		}
 	}
 }

-// calculateInterval returns the polling interval with exponential backoff based on
-// consecutive empty or error responses. The interval starts at FetchInterval and
-// doubles with each consecutive empty/error, capped at FetchIntervalMax.
-func (p *Poller) calculateInterval(s *workerState) time.Duration {
-	base := p.cfg.Runner.FetchInterval
-	maxInterval := p.cfg.Runner.FetchIntervalMax
+func (p *Poller) pollOnce(limiter *rate.Limiter) {
+	for {
+		if err := limiter.Wait(p.pollingCtx); err != nil {
+			if p.pollingCtx.Err() != nil {
+				log.WithError(err).Debug("limiter wait failed")
+			}
+			return
+		}
+		task, ok := p.fetchTask(p.pollingCtx)
+		if !ok {
+			continue
+		}

-	n := max(s.consecutiveEmpty, s.consecutiveErrors)
-	if n <= 1 {
-		return base
+		p.runTaskWithRecover(p.jobsCtx, task)
+		return
 	}
-
-	// Capped exponential backoff: base * 2^(n-1), max shift=5 so multiplier <= 32
-	shift := min(n-1, 5)
-	interval := base * time.Duration(int64(1)<<shift)
-	return min(interval, maxInterval)
-}
-
-// addJitter adds +/- 20% random jitter to the given duration to avoid thundering herd.
-func addJitter(d time.Duration) time.Duration {
-	if d <= 0 {
-		return d
-	}
-	// jitter range: [-20%, +20%] of d
-	jitterRange := int64(d) * 2 / 5 // 40% total range
-	if jitterRange <= 0 {
-		return d
-	}
-	jitter := rand.Int64N(jitterRange) - jitterRange/2
-	return d + time.Duration(jitter)
 }

 func (p *Poller) runTaskWithRecover(ctx context.Context, task *runnerv1.Task) {
@@ -228,42 +153,24 @@ func (p *Poller) runTaskWithRecover(ctx context.Context, task *runnerv1.Task) {
 	}
 }

-func (p *Poller) fetchTask(ctx context.Context, s *workerState) (*runnerv1.Task, bool) {
+func (p *Poller) fetchTask(ctx context.Context) (*runnerv1.Task, bool) {
 	reqCtx, cancel := context.WithTimeout(ctx, p.cfg.Runner.FetchTimeout)
 	defer cancel()

 	// Load the version value that was in the cache when the request was sent.
 	v := p.tasksVersion.Load()
-	start := time.Now()
 	resp, err := p.client.FetchTask(reqCtx, connect.NewRequest(&runnerv1.FetchTaskRequest{
 		TasksVersion: v,
 	}))
-
-	// DeadlineExceeded is the designed idle path for a long-poll: the server
-	// found no work within FetchTimeout. Treat it as an empty response and do
-	// not record the duration — the timeout value would swamp the histogram.
 	if errors.Is(err, context.DeadlineExceeded) {
-		s.consecutiveEmpty++
-		s.consecutiveErrors = 0 // timeout is a healthy idle response
-		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultEmpty).Inc()
-		return nil, false
+		err = nil
 	}
-	metrics.PollFetchDuration.Observe(time.Since(start).Seconds())
-
 	if err != nil {
 		log.WithError(err).Error("failed to fetch task")
-		s.consecutiveErrors++
-		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultError).Inc()
-		metrics.ClientErrors.WithLabelValues(metrics.LabelMethodFetchTask).Inc()
 		return nil, false
 	}

-	// Successful response — reset error counter.
-	s.consecutiveErrors = 0
-
 	if resp == nil || resp.Msg == nil {
-		s.consecutiveEmpty++
-		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultEmpty).Inc()
 		return nil, false
 	}

@@ -272,14 +179,11 @@ func (p *Poller) fetchTask(ctx context.Context, s *workerState) (*runnerv1.Task,
 	}

 	if resp.Msg.Task == nil {
-		s.consecutiveEmpty++
-		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultEmpty).Inc()
 		return nil, false
 	}

-	// got a task, set `tasksVersion` to zero to force query db in next request.
+	// got a task, set `tasksVersion` to zero to focre query db in next request.
 	p.tasksVersion.CompareAndSwap(resp.Msg.TasksVersion, 0)

-	metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultTask).Inc()
 	return resp.Msg.Task, true
 }
--- a/internal/app/poll/poller_test.go
+++ b/internal/app/poll/poller_test.go
@@ -1,260 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package poll
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"gitea.com/gitea/act_runner/internal/pkg/client/mocks"
-	"gitea.com/gitea/act_runner/internal/pkg/config"
-
-	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	connect_go "connectrpc.com/connect"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-)
-
-// TestPoller_WorkerStateCounters verifies that workerState correctly tracks
-// consecutive empty responses independently per state instance, and that
-// fetchTask increments only the relevant counter.
-func TestPoller_WorkerStateCounters(t *testing.T) {
-	client := mocks.NewClient(t)
-	client.On("FetchTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.FetchTaskRequest]) (*connect_go.Response[runnerv1.FetchTaskResponse], error) {
-			// Always return an empty response.
-			return connect_go.NewResponse(&runnerv1.FetchTaskResponse{}), nil
-		},
-	)
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	p := &Poller{client: client, cfg: cfg}
-
-	ctx := context.Background()
-	s1 := &workerState{}
-	s2 := &workerState{}
-
-	// Each worker independently observes one empty response.
-	_, ok := p.fetchTask(ctx, s1)
-	require.False(t, ok)
-	_, ok = p.fetchTask(ctx, s2)
-	require.False(t, ok)
-
-	assert.Equal(t, int64(1), s1.consecutiveEmpty, "worker 1 should only count its own empty response")
-	assert.Equal(t, int64(1), s2.consecutiveEmpty, "worker 2 should only count its own empty response")
-
-	// Worker 1 sees a second empty; worker 2 stays at 1.
-	_, ok = p.fetchTask(ctx, s1)
-	require.False(t, ok)
-	assert.Equal(t, int64(2), s1.consecutiveEmpty)
-	assert.Equal(t, int64(1), s2.consecutiveEmpty, "worker 2's counter must not be affected by worker 1's empty fetches")
-}
-
-// TestPoller_FetchErrorIncrementsErrorsOnly verifies that a fetch error
-// increments only the per-worker error counter, not the empty counter.
-func TestPoller_FetchErrorIncrementsErrorsOnly(t *testing.T) {
-	client := mocks.NewClient(t)
-	client.On("FetchTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.FetchTaskRequest]) (*connect_go.Response[runnerv1.FetchTaskResponse], error) {
-			return nil, errors.New("network unreachable")
-		},
-	)
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	p := &Poller{client: client, cfg: cfg}
-
-	s := &workerState{}
-	_, ok := p.fetchTask(context.Background(), s)
-	require.False(t, ok)
-	assert.Equal(t, int64(1), s.consecutiveErrors)
-	assert.Equal(t, int64(0), s.consecutiveEmpty)
-}
-
-// TestPoller_CalculateInterval verifies the exponential backoff math is
-// correctly driven by the workerState counters.
-func TestPoller_CalculateInterval(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.Runner.FetchInterval = 2 * time.Second
-	cfg.Runner.FetchIntervalMax = 60 * time.Second
-	p := &Poller{cfg: cfg}
-
-	cases := []struct {
-		name         string
-		empty, errs  int64
-		wantInterval time.Duration
-	}{
-		{"first poll, no backoff", 0, 0, 2 * time.Second},
-		{"single empty, still base", 1, 0, 2 * time.Second},
-		{"two empties, doubled", 2, 0, 4 * time.Second},
-		{"five empties, capped path", 5, 0, 32 * time.Second},
-		{"many empties, capped at max", 20, 0, 60 * time.Second},
-		{"errors drive backoff too", 0, 3, 8 * time.Second},
-		{"max(empty, errors) wins", 2, 4, 16 * time.Second},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			s := &workerState{consecutiveEmpty: tc.empty, consecutiveErrors: tc.errs}
-			assert.Equal(t, tc.wantInterval, p.calculateInterval(s))
-		})
-	}
-}
-
-// atomicMax atomically updates target to max(target, val).
-func atomicMax(target *atomic.Int64, val int64) {
-	for {
-		old := target.Load()
-		if val <= old || target.CompareAndSwap(old, val) {
-			break
-		}
-	}
-}
-
-type mockRunner struct {
-	delay          time.Duration
-	running        atomic.Int64
-	maxConcurrent  atomic.Int64
-	totalCompleted atomic.Int64
-}
-
-func (m *mockRunner) Run(ctx context.Context, _ *runnerv1.Task) error {
-	atomicMax(&m.maxConcurrent, m.running.Add(1))
-	select {
-	case <-time.After(m.delay):
-	case <-ctx.Done():
-	}
-	m.running.Add(-1)
-	m.totalCompleted.Add(1)
-	return nil
-}
-
-// TestPoller_ConcurrencyLimitedByCapacity verifies that with capacity=3 and
-// 6 available tasks, at most 3 tasks run concurrently, and FetchTask is
-// never called concurrently (single poller).
-func TestPoller_ConcurrencyLimitedByCapacity(t *testing.T) {
-	const (
-		capacity   = 3
-		totalTasks = 6
-		taskDelay  = 50 * time.Millisecond
-	)
-
-	var (
-		tasksReturned  atomic.Int64
-		fetchConcur    atomic.Int64
-		maxFetchConcur atomic.Int64
-	)
-
-	cli := mocks.NewClient(t)
-	cli.On("FetchTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.FetchTaskRequest]) (*connect_go.Response[runnerv1.FetchTaskResponse], error) {
-			atomicMax(&maxFetchConcur, fetchConcur.Add(1))
-			defer fetchConcur.Add(-1)
-
-			n := tasksReturned.Add(1)
-			if n <= totalTasks {
-				return connect_go.NewResponse(&runnerv1.FetchTaskResponse{
-					Task: &runnerv1.Task{Id: n},
-				}), nil
-			}
-			return connect_go.NewResponse(&runnerv1.FetchTaskResponse{}), nil
-		},
-	)
-
-	runner := &mockRunner{delay: taskDelay}
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.Runner.Capacity = capacity
-	cfg.Runner.FetchInterval = 10 * time.Millisecond
-	cfg.Runner.FetchIntervalMax = 10 * time.Millisecond
-
-	poller := New(cfg, cli, runner)
-
-	var wg sync.WaitGroup
-	wg.Go(poller.Poll)
-
-	require.Eventually(t, func() bool {
-		return runner.totalCompleted.Load() >= totalTasks
-	}, 2*time.Second, 10*time.Millisecond, "all tasks should complete")
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-	err = poller.Shutdown(ctx)
-	require.NoError(t, err)
-	wg.Wait()
-
-	assert.LessOrEqual(t, runner.maxConcurrent.Load(), int64(capacity),
-		"concurrent running tasks must not exceed capacity")
-	assert.GreaterOrEqual(t, runner.maxConcurrent.Load(), int64(2),
-		"with 6 tasks and capacity 3, at least 2 should overlap")
-	assert.Equal(t, int64(1), maxFetchConcur.Load(),
-		"FetchTask must never be called concurrently (single poller)")
-	assert.Equal(t, int64(totalTasks), runner.totalCompleted.Load(),
-		"all tasks should have been executed")
-}
-
-// TestPoller_ShutdownForcesJobsOnTimeout locks in the fix for a
-// pre-existing bug where Shutdown's timeout branch used a blocking
-// `<-p.done` receive, leaving p.shutdownJobs() unreachable. With a
-// task parked on jobsCtx and a Shutdown deadline shorter than the
-// task's natural completion, Shutdown must force-cancel via
-// shutdownJobs() and return ctx.Err() promptly — not block until the
-// task would have finished on its own.
-func TestPoller_ShutdownForcesJobsOnTimeout(t *testing.T) {
-	var served atomic.Bool
-	cli := mocks.NewClient(t)
-	cli.On("FetchTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.FetchTaskRequest]) (*connect_go.Response[runnerv1.FetchTaskResponse], error) {
-			if served.CompareAndSwap(false, true) {
-				return connect_go.NewResponse(&runnerv1.FetchTaskResponse{
-					Task: &runnerv1.Task{Id: 1},
-				}), nil
-			}
-			return connect_go.NewResponse(&runnerv1.FetchTaskResponse{}), nil
-		},
-	)
-
-	// delay >> Shutdown timeout: Run only returns when jobsCtx is
-	// cancelled by shutdownJobs().
-	runner := &mockRunner{delay: 30 * time.Second}
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.Runner.Capacity = 1
-	cfg.Runner.FetchInterval = 10 * time.Millisecond
-	cfg.Runner.FetchIntervalMax = 10 * time.Millisecond
-
-	poller := New(cfg, cli, runner)
-
-	var wg sync.WaitGroup
-	wg.Go(poller.Poll)
-
-	require.Eventually(t, func() bool {
-		return runner.running.Load() == 1
-	}, time.Second, 10*time.Millisecond, "task should start running")
-
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-	defer cancel()
-	start := time.Now()
-	err = poller.Shutdown(ctx)
-	elapsed := time.Since(start)
-
-	require.ErrorIs(t, err, context.DeadlineExceeded)
-	// With the fix, Shutdown returns shortly after the deadline once
-	// the forced job unwinds. Without the fix, the blocking <-p.done
-	// would hang for the full 30s mockRunner delay.
-	assert.Less(t, elapsed, 5*time.Second,
-		"Shutdown must not block on the parked task; shutdownJobs() must run on timeout")
-
-	wg.Wait()
-	assert.Equal(t, int64(1), runner.totalCompleted.Load(),
-		"the parked task must be cancelled and unwound")
-}
--- a/internal/app/run/logging.go
+++ b/internal/app/run/logging.go
@@ -5,20 +5,34 @@ package run

 import (
 	"io"
+	"os"

+	"gitea.com/gitea/act_runner/internal/pkg/report"
 	log "github.com/sirupsen/logrus"
 )

-// NullLogger is used to create a new JobLogger to discard logs. This
-// will prevent these logs from being logged to the stdout, but
-// forward them to the Reporter via its hook.
-type NullLogger struct{}
+type JobLoggerFactoryWithInfoLevel struct{}

-// WithJobLogger creates a new logrus.Logger that will discard all logs.
-func (n NullLogger) WithJobLogger() *log.Logger {
-	logger := log.New()
-	logger.SetOutput(io.Discard)
-	logger.SetLevel(log.TraceLevel)
-
-	return logger
+// WithJobLogger implements [runner.JobLoggerFactory].
+func (j *JobLoggerFactoryWithInfoLevel) WithJobLogger() *log.Logger {
+	jobLogger := log.New()
+	jobLogger.SetLevel(log.InfoLevel)
+	return jobLogger
+}
+
+type JobLoggerWithReporter struct {
+	Reporter      *report.Reporter
+	LogToTerminal bool
+}
+
+// WithJobLogger implements [runner.JobLoggerFactory].
+func (j *JobLoggerWithReporter) WithJobLogger() *log.Logger {
+	jobLogger := log.New()
+	if j.LogToTerminal {
+		jobLogger.SetOutput(os.Stdout)
+	} else {
+		jobLogger.SetOutput(io.Discard)
+	}
+	jobLogger.AddHook(j.Reporter)
+	return jobLogger
 }
--- a/internal/app/run/runner.go
+++ b/internal/app/run/runner.go
@@ -8,28 +8,24 @@ import (
 	"encoding/json"
 	"fmt"
 	"maps"
-	"os"
 	"path/filepath"
 	"strings"
 	"sync"
-	"sync/atomic"
-	"time"
+
+	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
+	"connectrpc.com/connect"
+	"github.com/actions-oss/act-cli/pkg/artifactcache"
+	"github.com/actions-oss/act-cli/pkg/model"
+	"github.com/actions-oss/act-cli/pkg/runner"
+	"github.com/actions-oss/act-cli/pkg/schema"
+	"github.com/docker/docker/api/types/container"
+	log "github.com/sirupsen/logrus"

 	"gitea.com/gitea/act_runner/internal/pkg/client"
 	"gitea.com/gitea/act_runner/internal/pkg/config"
 	"gitea.com/gitea/act_runner/internal/pkg/labels"
-	"gitea.com/gitea/act_runner/internal/pkg/metrics"
 	"gitea.com/gitea/act_runner/internal/pkg/report"
 	"gitea.com/gitea/act_runner/internal/pkg/ver"
-
-	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"connectrpc.com/connect"
-	"github.com/docker/docker/api/types/container"
-	"github.com/nektos/act/pkg/artifactcache"
-	"github.com/nektos/act/pkg/common"
-	"github.com/nektos/act/pkg/model"
-	"github.com/nektos/act/pkg/runner"
-	log "github.com/sirupsen/logrus"
 )

 // Runner runs the pipeline.
@@ -43,7 +39,6 @@ type Runner struct {
 	envs   map[string]string

 	runningTasks sync.Map
-	runningCount atomic.Int64
 }

 func NewRunner(cfg *config.Config, reg *config.Registration, cli client.Client) *Runner {
@@ -99,25 +94,16 @@ func (r *Runner) Run(ctx context.Context, task *runnerv1.Task) error {
 	r.runningTasks.Store(task.Id, struct{}{})
 	defer r.runningTasks.Delete(task.Id)

-	r.runningCount.Add(1)
-
-	start := time.Now()
-
 	ctx, cancel := context.WithTimeout(ctx, r.cfg.Runner.Timeout)
 	defer cancel()
-	reporter := report.NewReporter(ctx, cancel, r.client, task, r.cfg)
+	reporter := report.NewReporter(ctx, cancel, r.client, task)
 	var runErr error
 	defer func() {
-		r.runningCount.Add(-1)
-
 		lastWords := ""
 		if runErr != nil {
 			lastWords = runErr.Error()
 		}
 		_ = reporter.Close(lastWords)
-
-		metrics.JobDuration.Observe(time.Since(start).Seconds())
-		metrics.JobsTotal.WithLabelValues(metrics.ResultToStatusLabel(reporter.Result())).Inc()
 	}()
 	reporter.RunDaemon()
 	runErr = r.run(ctx, task, reporter)
@@ -150,12 +136,20 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 		return err
 	}

+	// TODO GITEA
 	plan, err := model.CombineWorkflowPlanner(workflow).PlanJob(jobID)
 	if err != nil {
 		return err
 	}
 	job := workflow.GetJob(jobID)
-	reporter.ResetSteps(len(job.Steps))
+	var stepIds []string
+	for i, v := range job.Steps {
+		if v.ID == "" {
+			v.ID = fmt.Sprint(i)
+		}
+		stepIds = append(stepIds, v.ID)
+	}
+	reporter.SetStepIdMapping(stepIds...)

 	taskContext := task.Context.Fields

@@ -167,7 +161,6 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 		Event:           taskContext["event"].GetStructValue().AsMap(),
 		RunID:           taskContext["run_id"].GetStringValue(),
 		RunNumber:       taskContext["run_number"].GetStringValue(),
-		RunAttempt:      taskContext["run_attempt"].GetStringValue(),
 		Actor:           taskContext["actor"].GetStringValue(),
 		Repository:      taskContext["repository"].GetStringValue(),
 		EventName:       taskContext["event_name"].GetStringValue(),
@@ -200,53 +193,70 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 	}
 	r.envs["ACTIONS_RUNTIME_TOKEN"] = giteaRuntimeToken

+	// TODO GITEA
 	eventJSON, err := json.Marshal(preset.Event)
 	if err != nil {
 		return err
 	}

-	maxLifetime := 3 * time.Hour
-	if deadline, ok := ctx.Deadline(); ok {
-		maxLifetime = time.Until(deadline)
-	}
+	// maxLifetime := 3 * time.Hour
+	// if deadline, ok := ctx.Deadline(); ok {
+	// 	maxLifetime = time.Until(deadline)
+	// }

-	workdirParent := strings.TrimLeft(r.cfg.Container.WorkdirParent, "/")
-	if r.cfg.Container.BindWorkdir {
-		// Append the task ID to isolate concurrent jobs from the same repo.
-		workdirParent = fmt.Sprintf("%s/%d", workdirParent, task.Id)
-	}
-	workdir := filepath.FromSlash(fmt.Sprintf("/%s/%s", workdirParent, preset.Repository))
+	actCtx := map[string]interface{}{}
+	forgeCtx := task.Context.AsMap()
+	actCtx["github"] = forgeCtx
+	actCtx["gitea"] = forgeCtx

 	runnerConfig := &runner.Config{
 		// On Linux, Workdir will be like "/<parent_directory>/<owner>/<repo>"
 		// On Windows, Workdir will be like "\<parent_directory>\<owner>\<repo>"
-		Workdir:        workdir,
-		BindWorkdir:    r.cfg.Container.BindWorkdir,
+		Workdir:        filepath.FromSlash(fmt.Sprintf("/%s/%s", strings.TrimLeft(r.cfg.Container.WorkdirParent, "/"), preset.Repository)),
+		BindWorkdir:    false,
 		ActionCacheDir: filepath.FromSlash(r.cfg.Host.WorkdirParent),

-		ReuseContainers:       false,
-		ForcePull:             r.cfg.Container.ForcePull,
-		ForceRebuild:          r.cfg.Container.ForceRebuild,
-		LogOutput:             true,
-		JSONLogger:            false,
-		Env:                   r.envs,
-		Secrets:               task.Secrets,
-		GitHubInstance:        strings.TrimSuffix(r.client.Address(), "/"),
-		AutoRemove:            true,
-		NoSkipCheckout:        true,
-		PresetGitHubContext:   preset,
-		EventJSON:             string(eventJSON),
-		ContainerNamePrefix:   fmt.Sprintf("GITEA-ACTIONS-TASK-%d", task.Id),
-		ContainerMaxLifetime:  maxLifetime,
+		ReuseContainers: false,
+		ForcePull:       r.cfg.Container.ForcePull,
+		ForceRebuild:    r.cfg.Container.ForceRebuild,
+		LogOutput:       true,
+		JSONLogger:      false,
+		Env:             r.envs,
+		Secrets:         task.Secrets,
+		// GitHubInstance:  strings.TrimSuffix(r.client.Address(), "/"),
+		AutoRemove:     true,
+		NoSkipCheckout: true,
+		// TODO GITEA
+		// PresetGitHubContext:   preset,
+		EventJSON: string(eventJSON),
+		// ContainerNamePrefix:   fmt.Sprintf("GITEA-ACTIONS-TASK-%d", task.Id),
+		// ContainerMaxLifetime:  maxLifetime,
 		ContainerNetworkMode:  container.NetworkMode(r.cfg.Container.Network),
 		ContainerOptions:      r.cfg.Container.Options,
 		ContainerDaemonSocket: r.cfg.Container.DockerHost,
 		Privileged:            r.cfg.Container.Privileged,
-		DefaultActionInstance: r.getDefaultActionsURL(task),
-		PlatformPicker:        r.labels.PickPlatform,
-		Vars:                  task.Vars,
-		ValidVolumes:          r.cfg.Container.ValidVolumes,
-		InsecureSkipTLS:       r.cfg.Runner.Insecure,
+
+		Platforms: map[string]string{
+			"dummy": "-self-hosted",
+		},
+		// TODO GITEA
+		// DefaultActionInstance: r.getDefaultActionsURL(task),
+		// PlatformPicker:        r.labels.PickPlatform,
+		Vars: task.Vars,
+		// TODO GITEA
+		// ValidVolumes:          r.cfg.Container.ValidVolumes,
+		// InsecureSkipTLS:       r.cfg.Runner.Insecure,
+
+		GitHubServerURL:    strings.TrimSuffix(r.client.Address(), "/"),
+		GitHubAPIServerURL: strings.TrimSuffix(r.client.Address(), "/") + "/api/v1",
+		// Invalid but ok
+		GitHubGraphQlAPIServerURL: strings.TrimSuffix(r.client.Address(), "/api/graphql"),
+		MainContextNames:          []string{"gitea", "github"},
+
+		Action: model.ActionConfig{
+			Schema: schema.GetGiteaActionSchema(),
+		},
+		ContextData: actCtx,
 	}

 	rr, err := runner.New(runnerConfig)
@@ -257,31 +267,14 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.

 	reporter.Logf("workflow prepared")

-	// add logger recorders
-	ctx = common.WithLoggerHook(ctx, reporter)
-
-	if !log.IsLevelEnabled(log.DebugLevel) {
-		ctx = runner.WithJobLoggerFactory(ctx, NullLogger{})
-	}
+	// TODO GITEA
+	ctx = runner.WithJobLoggerFactory(ctx, &JobLoggerWithReporter{Reporter: reporter, LogToTerminal: log.IsLevelEnabled(log.DebugLevel)})

 	execErr := executor(ctx)
 	reporter.SetOutputs(job.Outputs)
-
-	if r.cfg.Container.BindWorkdir {
-		// Remove the entire task-specific directory (e.g. /workspace/<task_id>).
-		taskDir := filepath.FromSlash("/" + workdirParent)
-		if err := os.RemoveAll(taskDir); err != nil {
-			log.Warnf("failed to clean up workspace %s: %v", taskDir, err)
-		}
-	}
-
 	return execErr
 }

-func (r *Runner) RunningCount() int64 {
-	return r.runningCount.Load()
-}
-
 func (r *Runner) Declare(ctx context.Context, labels []string) (*connect.Response[runnerv1.DeclareResponse], error) {
 	return r.client.Declare(ctx, connect.NewRequest(&runnerv1.DeclareRequest{
 		Version: ver.Version(),
--- a/internal/app/run/workflow.go
+++ b/internal/app/run/workflow.go
@@ -10,12 +10,24 @@ import (
 	"strings"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"github.com/nektos/act/pkg/model"
-	"go.yaml.in/yaml/v4"
+	"github.com/actions-oss/act-cli/pkg/model"
+	"github.com/actions-oss/act-cli/pkg/schema"
+	"gopkg.in/yaml.v3"
 )

 func generateWorkflow(task *runnerv1.Task) (*model.Workflow, string, error) {
-	workflow, err := model.ReadWorkflow(bytes.NewReader(task.WorkflowPayload))
+	workflow, err := model.ReadWorkflow(bytes.NewReader(task.WorkflowPayload), model.WorkflowConfig{
+		// Schema: schema.GetGiteaWorkflowSchema(),
+		// Allow everything
+		Schema: &schema.Schema{
+			Definitions: map[string]schema.Definition{
+				"workflow-root": {
+					Context: []string{"github", "gitea", "env", "job", "matrix", "strategy", "inputs", "vars", "runner", "steps", "needs"},
+					OneOf:   &[]string{"any"},
+				},
+			},
+		},
+	})
 	if err != nil {
 		return nil, "", err
 	}
@@ -48,7 +60,9 @@ func generateWorkflow(task *runnerv1.Task) (*model.Workflow, string, error) {
 		})
 	}

+	// TODO GITEA
 	workflow.Jobs[jobID].RawNeeds = rawNeeds
+	workflow.Jobs[jobID].RawRunsOn.Encode("dummy")

 	return workflow, jobID, nil
 }
--- a/internal/app/run/workflow_test.go
+++ b/internal/app/run/workflow_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"github.com/nektos/act/pkg/model"
+	"github.com/actions-oss/act-cli/pkg/model"
 	"github.com/stretchr/testify/require"
 	"go.yaml.in/yaml/v4"
 	"gotest.tools/v3/assert"
--- a/internal/pkg/client/http.go
+++ b/internal/pkg/client/http.go
@@ -8,7 +8,6 @@ import (
 	"crypto/tls"
 	"net/http"
 	"strings"
-	"time"

 	"code.gitea.io/actions-proto-go/ping/v1/pingv1connect"
 	"code.gitea.io/actions-proto-go/runner/v1/runnerv1connect"
@@ -16,17 +15,16 @@ import (
 )

 func getHTTPClient(endpoint string, insecure bool) *http.Client {
-	transport := &http.Transport{
-		MaxIdleConns:        10,
-		MaxIdleConnsPerHost: 10, // All requests go to one host; default is 2 which causes frequent reconnects.
-		IdleConnTimeout:     90 * time.Second,
-	}
 	if strings.HasPrefix(endpoint, "https://") && insecure {
-		transport.TLSClientConfig = &tls.Config{
-			InsecureSkipVerify: true,
+		return &http.Client{
+			Transport: &http.Transport{
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
+			},
 		}
 	}
-	return &http.Client{Transport: transport}
+	return http.DefaultClient
 }

 // New returns a new runner client.
@@ -49,15 +47,14 @@ func New(endpoint string, insecure bool, uuid, token, version string, opts ...co
 		}
 	})))

-	httpClient := getHTTPClient(endpoint, insecure)
 	return &HTTPClient{
 		PingServiceClient: pingv1connect.NewPingServiceClient(
-			httpClient,
+			getHTTPClient(endpoint, insecure),
 			baseURL,
 			opts...,
 		),
 		RunnerServiceClient: runnerv1connect.NewRunnerServiceClient(
-			httpClient,
+			getHTTPClient(endpoint, insecure),
 			baseURL,
 			opts...,
 		),
--- a/internal/pkg/config/config.example.yaml
+++ b/internal/pkg/config/config.example.yaml
@@ -32,24 +32,6 @@ runner:
  fetch_timeout: 5s
  # The interval for fetching the job from the Gitea instance.
  fetch_interval: 2s
-  # The maximum interval for fetching the job from the Gitea instance.
-  # The runner uses exponential backoff when idle, increasing the interval up to this maximum.
-  # Set to 0 or same as fetch_interval to disable backoff.
-  fetch_interval_max: 60s
-  # The base interval for periodic log flush to the Gitea instance.
-  # Logs may be sent earlier if the buffer reaches log_report_batch_size
-  # or if log_report_max_latency expires after the first buffered row.
-  log_report_interval: 5s
-  # The maximum time a log row can wait before being sent.
-  # This ensures even a single log line appears on the frontend within this duration.
-  # Must be less than log_report_interval to have any effect.
-  log_report_max_latency: 3s
-  # Flush logs immediately when the buffer reaches this many rows.
-  # This ensures bursty output (e.g., npm install) is delivered promptly.
-  log_report_batch_size: 100
-  # The interval for reporting task state (step status, timing) to the Gitea instance.
-  # State is also reported immediately on step transitions (start/stop).
-  state_report_interval: 5s
  # The github_mirror of a runner is used to specify the mirror address of the github that pulls the action repository.
  # It works when something like `uses: actions/checkout@v4` is used and DEFAULT_ACTIONS_URL is set to github,
  # and github_mirror is not empty. In this case,
@@ -121,23 +103,8 @@ container:
  require_docker: false
  # Timeout to wait for the docker daemon to be reachable, if docker is required by require_docker or act_runner
  docker_timeout: 0s
-  # Bind the workspace to the host filesystem instead of using Docker volumes.
-  # This is required for Docker-in-Docker (DinD) setups when jobs use docker compose
-  # with bind mounts (e.g., ".:/app"), as volume-based workspaces are not accessible
-  # from the DinD daemon's filesystem. When enabled, ensure the workspace parent
-  # directory is also mounted into the runner container and listed in valid_volumes.
-  bind_workdir: false

 host:
  # The parent directory of a job's working directory.
  # If it's empty, $HOME/.cache/act/ will be used.
  workdir_parent:
-
-metrics:
-  # Enable the Prometheus metrics endpoint.
-  # When enabled, metrics are served at http://<addr>/metrics and a liveness check at /healthz.
-  enabled: false
-  # The address for the metrics HTTP server to listen on.
-  # Defaults to localhost only. Set to ":9101" to allow external access,
-  # but ensure the port is firewall-protected as there is no authentication.
-  addr: "127.0.0.1:9101"
--- a/internal/pkg/config/config.go
+++ b/internal/pkg/config/config.go
@@ -22,22 +22,17 @@ type Log struct {

 // Runner represents the configuration for the runner.
 type Runner struct {
-	File                string            `yaml:"file"`                   // File specifies the file path for the runner.
-	Capacity            int               `yaml:"capacity"`               // Capacity specifies the capacity of the runner.
-	Envs                map[string]string `yaml:"envs"`                   // Envs stores environment variables for the runner.
-	EnvFile             string            `yaml:"env_file"`               // EnvFile specifies the path to the file containing environment variables for the runner.
-	Timeout             time.Duration     `yaml:"timeout"`                // Timeout specifies the duration for runner timeout.
-	ShutdownTimeout     time.Duration     `yaml:"shutdown_timeout"`       // ShutdownTimeout specifies the duration to wait for running jobs to complete during a shutdown of the runner.
-	Insecure            bool              `yaml:"insecure"`               // Insecure indicates whether the runner operates in an insecure mode.
-	FetchTimeout        time.Duration     `yaml:"fetch_timeout"`          // FetchTimeout specifies the timeout duration for fetching resources.
-	FetchInterval       time.Duration     `yaml:"fetch_interval"`         // FetchInterval specifies the interval duration for fetching resources.
-	FetchIntervalMax    time.Duration     `yaml:"fetch_interval_max"`     // FetchIntervalMax specifies the maximum backoff interval when idle.
-	LogReportInterval   time.Duration     `yaml:"log_report_interval"`    // LogReportInterval specifies the base interval for periodic log flush.
-	LogReportMaxLatency time.Duration     `yaml:"log_report_max_latency"` // LogReportMaxLatency specifies the max time a log row can wait before being sent.
-	LogReportBatchSize  int               `yaml:"log_report_batch_size"`  // LogReportBatchSize triggers immediate log flush when buffer reaches this size.
-	StateReportInterval time.Duration     `yaml:"state_report_interval"`  // StateReportInterval specifies the interval for state reporting.
-	Labels              []string          `yaml:"labels"`                 // Labels specify the labels of the runner. Labels are declared on each startup
-	GithubMirror        string            `yaml:"github_mirror"`          // GithubMirror defines what mirrors should be used when using github
+	File            string            `yaml:"file"`             // File specifies the file path for the runner.
+	Capacity        int               `yaml:"capacity"`         // Capacity specifies the capacity of the runner.
+	Envs            map[string]string `yaml:"envs"`             // Envs stores environment variables for the runner.
+	EnvFile         string            `yaml:"env_file"`         // EnvFile specifies the path to the file containing environment variables for the runner.
+	Timeout         time.Duration     `yaml:"timeout"`          // Timeout specifies the duration for runner timeout.
+	ShutdownTimeout time.Duration     `yaml:"shutdown_timeout"` // ShutdownTimeout specifies the duration to wait for running jobs to complete during a shutdown of the runner.
+	Insecure        bool              `yaml:"insecure"`         // Insecure indicates whether the runner operates in an insecure mode.
+	FetchTimeout    time.Duration     `yaml:"fetch_timeout"`    // FetchTimeout specifies the timeout duration for fetching resources.
+	FetchInterval   time.Duration     `yaml:"fetch_interval"`   // FetchInterval specifies the interval duration for fetching resources.
+	Labels          []string          `yaml:"labels"`           // Labels specify the labels of the runner. Labels are declared on each startup
+	GithubMirror    string            `yaml:"github_mirror"`    // GithubMirror defines what mirrors should be used when using github
 }

 // Cache represents the configuration for caching.
@@ -62,7 +57,6 @@ type Container struct {
 	ForceRebuild  bool          `yaml:"force_rebuild"`  // Rebuild docker image(s) even if already present
 	RequireDocker bool          `yaml:"require_docker"` // Always require a reachable docker daemon, even if not required by act_runner
 	DockerTimeout time.Duration `yaml:"docker_timeout"` // Timeout to wait for the docker daemon to be reachable, if docker is required by require_docker or act_runner
-	BindWorkdir   bool          `yaml:"bind_workdir"`   // BindWorkdir binds the workspace to the host filesystem instead of using Docker volumes. Required for DinD when jobs use docker compose with bind mounts.
 }

 // Host represents the configuration for the host.
@@ -70,12 +64,6 @@ type Host struct {
 	WorkdirParent string `yaml:"workdir_parent"` // WorkdirParent specifies the parent directory for the host's working directory.
 }

-// Metrics represents the configuration for the Prometheus metrics endpoint.
-type Metrics struct {
-	Enabled bool   `yaml:"enabled"` // Enabled indicates whether the metrics endpoint is exposed.
-	Addr    string `yaml:"addr"`    // Addr specifies the listen address for the metrics HTTP server (e.g., ":9101").
-}
-
 // Config represents the overall configuration.
 type Config struct {
 	Log       Log       `yaml:"log"`       // Log represents the configuration for logging.
@@ -83,7 +71,6 @@ type Config struct {
 	Cache     Cache     `yaml:"cache"`     // Cache represents the configuration for caching.
 	Container Container `yaml:"container"` // Container represents the configuration for the container.
 	Host      Host      `yaml:"host"`      // Host represents the configuration for the host.
-	Metrics   Metrics   `yaml:"metrics"`   // Metrics represents the configuration for the Prometheus metrics endpoint.
 }

 // LoadDefault returns the default configuration.
@@ -149,35 +136,6 @@ func LoadDefault(file string) (*Config, error) {
 	if cfg.Runner.FetchInterval <= 0 {
 		cfg.Runner.FetchInterval = 2 * time.Second
 	}
-	if cfg.Runner.FetchIntervalMax <= 0 {
-		cfg.Runner.FetchIntervalMax = 60 * time.Second
-	}
-	if cfg.Runner.LogReportInterval <= 0 {
-		cfg.Runner.LogReportInterval = 5 * time.Second
-	}
-	if cfg.Runner.LogReportMaxLatency <= 0 {
-		cfg.Runner.LogReportMaxLatency = 3 * time.Second
-	}
-	if cfg.Runner.LogReportBatchSize <= 0 {
-		cfg.Runner.LogReportBatchSize = 100
-	}
-	if cfg.Runner.StateReportInterval <= 0 {
-		cfg.Runner.StateReportInterval = 5 * time.Second
-	}
-	if cfg.Metrics.Addr == "" {
-		cfg.Metrics.Addr = "127.0.0.1:9101"
-	}
-
-	// Validate and fix invalid config combinations to prevent confusing behavior.
-	if cfg.Runner.FetchIntervalMax < cfg.Runner.FetchInterval {
-		log.Warnf("fetch_interval_max (%v) is less than fetch_interval (%v), setting fetch_interval_max to fetch_interval",
-			cfg.Runner.FetchIntervalMax, cfg.Runner.FetchInterval)
-		cfg.Runner.FetchIntervalMax = cfg.Runner.FetchInterval
-	}
-	if cfg.Runner.LogReportMaxLatency >= cfg.Runner.LogReportInterval {
-		log.Warnf("log_report_max_latency (%v) >= log_report_interval (%v), the max-latency timer will never fire before the periodic ticker; consider lowering log_report_max_latency",
-			cfg.Runner.LogReportMaxLatency, cfg.Runner.LogReportInterval)
-	}

 	// although `container.network_mode` will be deprecated, but we have to be compatible with it for now.
 	if cfg.Container.NetworkMode != "" && cfg.Container.Network == "" {
--- a/internal/pkg/metrics/metrics.go
+++ b/internal/pkg/metrics/metrics.go
@@ -1,216 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package metrics
-
-import (
-	"sync"
-	"time"
-
-	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/collectors"
-)
-
-// Namespace is the Prometheus namespace for all act_runner metrics.
-const Namespace = "act_runner"
-
-// Label value constants for Prometheus metrics.
-// Using constants prevents typos from silently creating new time-series.
-//
-// LabelResult* values are used on metrics with label key "result" (RPC outcomes).
-// LabelStatus* values are used on metrics with label key "status" (job outcomes).
-const (
-	LabelResultTask    = "task"
-	LabelResultEmpty   = "empty"
-	LabelResultError   = "error"
-	LabelResultSuccess = "success"
-
-	LabelMethodFetchTask  = "FetchTask"
-	LabelMethodUpdateLog  = "UpdateLog"
-	LabelMethodUpdateTask = "UpdateTask"
-
-	LabelStatusSuccess   = "success"
-	LabelStatusFailure   = "failure"
-	LabelStatusCancelled = "cancelled"
-	LabelStatusSkipped   = "skipped"
-	LabelStatusUnknown   = "unknown"
-)
-
-// rpcDurationBuckets covers the expected latency range for short-running
-// UpdateLog / UpdateTask RPCs. FetchTask uses its own buckets (it has a 10s tail).
-var rpcDurationBuckets = []float64{0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5}
-
-// ResultToStatusLabel maps a runnerv1.Result to the "status" label value used on job metrics.
-func ResultToStatusLabel(r runnerv1.Result) string {
-	switch r {
-	case runnerv1.Result_RESULT_SUCCESS:
-		return LabelStatusSuccess
-	case runnerv1.Result_RESULT_FAILURE:
-		return LabelStatusFailure
-	case runnerv1.Result_RESULT_CANCELLED:
-		return LabelStatusCancelled
-	case runnerv1.Result_RESULT_SKIPPED:
-		return LabelStatusSkipped
-	default:
-		return LabelStatusUnknown
-	}
-}
-
-var (
-	RunnerInfo = prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace: Namespace,
-		Name:      "info",
-		Help:      "Runner metadata. Always 1. Labels carry version and name.",
-	}, []string{"version", "name"})
-
-	RunnerCapacity = prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace: Namespace,
-		Name:      "capacity",
-		Help:      "Configured maximum concurrent jobs.",
-	})
-
-	PollFetchTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: Namespace,
-		Subsystem: "poll",
-		Name:      "fetch_total",
-		Help:      "Total number of FetchTask RPCs by result (task, empty, error).",
-	}, []string{"result"})
-
-	PollFetchDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace: Namespace,
-		Subsystem: "poll",
-		Name:      "fetch_duration_seconds",
-		Help:      "Latency of FetchTask RPCs, excluding expected long-poll timeouts.",
-		Buckets:   []float64{0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10},
-	})
-
-	PollBackoffSeconds = prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace: Namespace,
-		Subsystem: "poll",
-		Name:      "backoff_seconds",
-		Help:      "Last observed polling backoff interval in seconds.",
-	})
-
-	JobsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: Namespace,
-		Subsystem: "job",
-		Name:      "total",
-		Help:      "Total jobs processed by status (success, failure, cancelled, skipped, unknown).",
-	}, []string{"status"})
-
-	JobDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace: Namespace,
-		Subsystem: "job",
-		Name:      "duration_seconds",
-		Help:      "Duration of job execution from start to finish.",
-		Buckets:   prometheus.ExponentialBuckets(1, 2, 14), // 1s to ~4.5h
-	})
-
-	ReportLogTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: Namespace,
-		Subsystem: "report",
-		Name:      "log_total",
-		Help:      "Total UpdateLog RPCs by result (success, error).",
-	}, []string{"result"})
-
-	ReportLogDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace: Namespace,
-		Subsystem: "report",
-		Name:      "log_duration_seconds",
-		Help:      "Latency of UpdateLog RPCs.",
-		Buckets:   rpcDurationBuckets,
-	})
-
-	ReportStateTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: Namespace,
-		Subsystem: "report",
-		Name:      "state_total",
-		Help:      "Total UpdateTask (state) RPCs by result (success, error).",
-	}, []string{"result"})
-
-	ReportStateDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace: Namespace,
-		Subsystem: "report",
-		Name:      "state_duration_seconds",
-		Help:      "Latency of UpdateTask RPCs.",
-		Buckets:   rpcDurationBuckets,
-	})
-
-	ReportLogBufferRows = prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace: Namespace,
-		Subsystem: "report",
-		Name:      "log_buffer_rows",
-		Help:      "Current number of buffered log rows awaiting send.",
-	})
-
-	ClientErrors = prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: Namespace,
-		Subsystem: "client",
-		Name:      "errors_total",
-		Help:      "Total client RPC errors by method.",
-	}, []string{"method"})
-)
-
-// Registry is the custom Prometheus registry used by the runner.
-var Registry = prometheus.NewRegistry()
-
-var initOnce sync.Once
-
-// Init registers all static metrics and the standard Go/process collectors.
-// Safe to call multiple times; only the first call has effect.
-func Init() {
-	initOnce.Do(func() {
-		Registry.MustRegister(
-			collectors.NewGoCollector(),
-			collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
-			RunnerInfo, RunnerCapacity,
-			PollFetchTotal, PollFetchDuration, PollBackoffSeconds,
-			JobsTotal, JobDuration,
-			ReportLogTotal, ReportLogDuration,
-			ReportStateTotal, ReportStateDuration, ReportLogBufferRows,
-			ClientErrors,
-		)
-	})
-}
-
-// RegisterUptimeFunc registers a GaugeFunc that reports seconds since startTime.
-func RegisterUptimeFunc(startTime time.Time) {
-	Registry.MustRegister(prometheus.NewGaugeFunc(
-		prometheus.GaugeOpts{
-			Namespace: Namespace,
-			Name:      "uptime_seconds",
-			Help:      "Seconds since the runner daemon started.",
-		},
-		func() float64 { return time.Since(startTime).Seconds() },
-	))
-}
-
-// RegisterRunningJobsFunc registers GaugeFuncs for the running job count and
-// capacity utilisation ratio, evaluated lazily at Prometheus scrape time.
-func RegisterRunningJobsFunc(countFn func() int64, capacity int) {
-	capF := float64(capacity)
-	Registry.MustRegister(prometheus.NewGaugeFunc(
-		prometheus.GaugeOpts{
-			Namespace: Namespace,
-			Subsystem: "job",
-			Name:      "running",
-			Help:      "Number of jobs currently executing.",
-		},
-		func() float64 { return float64(countFn()) },
-	))
-	Registry.MustRegister(prometheus.NewGaugeFunc(
-		prometheus.GaugeOpts{
-			Namespace: Namespace,
-			Subsystem: "job",
-			Name:      "capacity_utilization_ratio",
-			Help:      "Ratio of running jobs to configured capacity (0.0-1.0).",
-		},
-		func() float64 {
-			if capF <= 0 {
-				return 0
-			}
-			return float64(countFn()) / capF
-		},
-	))
-}
--- a/internal/pkg/metrics/server.go
+++ b/internal/pkg/metrics/server.go
@@ -1,50 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package metrics
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	log "github.com/sirupsen/logrus"
-)
-
-// StartServer starts an HTTP server that serves Prometheus metrics on /metrics
-// and a liveness check on /healthz. The server shuts down when ctx is cancelled.
-// Call Init() before StartServer to register metrics with the Registry.
-func StartServer(ctx context.Context, addr string) {
-	mux := http.NewServeMux()
-	mux.Handle("/metrics", promhttp.HandlerFor(Registry, promhttp.HandlerOpts{}))
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("ok"))
-	})
-
-	srv := &http.Server{
-		Addr:              addr,
-		Handler:           mux,
-		ReadHeaderTimeout: 5 * time.Second,
-		ReadTimeout:       10 * time.Second,
-		WriteTimeout:      10 * time.Second,
-		IdleTimeout:       60 * time.Second,
-	}
-
-	go func() {
-		log.Infof("metrics server listening on %s", addr)
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.WithError(err).Error("metrics server failed")
-		}
-	}()
-
-	go func() {
-		<-ctx.Done()
-		shutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		if err := srv.Shutdown(shutCtx); err != nil {
-			log.WithError(err).Warn("metrics server shutdown error")
-		}
-	}()
-}
--- a/internal/pkg/report/reporter.go
+++ b/internal/pkg/report/reporter.go
@@ -8,20 +8,19 @@ import (
 	"errors"
 	"fmt"
 	"regexp"
+	"slices"
 	"strings"
 	"sync"
 	"time"

-	"gitea.com/gitea/act_runner/internal/pkg/client"
-	"gitea.com/gitea/act_runner/internal/pkg/config"
-	"gitea.com/gitea/act_runner/internal/pkg/metrics"
-
 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
 	"connectrpc.com/connect"
 	"github.com/avast/retry-go/v4"
 	log "github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"gitea.com/gitea/act_runner/internal/pkg/client"
 )

 type Reporter struct {
@@ -37,32 +36,18 @@ type Reporter struct {
 	logReplacer *strings.Replacer
 	oldnew      []string

-	// lastLogBufferRows is the last value written to the ReportLogBufferRows
-	// gauge; guarded by clientM (the same lock held around each ReportLog call)
-	// so the gauge skips no-op Set calls when the buffer size is unchanged.
-	lastLogBufferRows int
-
-	state        *runnerv1.TaskState
-	stateChanged bool
-	stateMu      sync.RWMutex
-	outputs      sync.Map
-	daemon       chan struct{}
-
-	// Adaptive batching control
-	logReportInterval   time.Duration
-	logReportMaxLatency time.Duration
-	logBatchSize        int
-	stateReportInterval time.Duration
-
-	// Event notification channels (non-blocking, buffered 1)
-	logNotify   chan struct{} // signal: new log rows arrived
-	stateNotify chan struct{} // signal: step transition (start/stop)
+	state   *runnerv1.TaskState
+	stateMu sync.RWMutex
+	outputs sync.Map
+	daemon  chan struct{}

 	debugOutputEnabled  bool
 	stopCommandEndToken string
+
+	stepIds []string
 }

-func NewReporter(ctx context.Context, cancel context.CancelFunc, client client.Client, task *runnerv1.Task, cfg *config.Config) *Reporter {
+func NewReporter(ctx context.Context, cancel context.CancelFunc, client client.Client, task *runnerv1.Task) *Reporter {
 	var oldnew []string
 	if v := task.Context.Fields["token"].GetStringValue(); v != "" {
 		oldnew = append(oldnew, v, "***")
@@ -75,17 +60,11 @@ func NewReporter(ctx context.Context, cancel context.CancelFunc, client client.C
 	}

 	rv := &Reporter{
-		ctx:                 ctx,
-		cancel:              cancel,
-		client:              client,
-		oldnew:              oldnew,
-		logReplacer:         strings.NewReplacer(oldnew...),
-		logReportInterval:   cfg.Runner.LogReportInterval,
-		logReportMaxLatency: cfg.Runner.LogReportMaxLatency,
-		logBatchSize:        cfg.Runner.LogReportBatchSize,
-		stateReportInterval: cfg.Runner.StateReportInterval,
-		logNotify:           make(chan struct{}, 1),
-		stateNotify:         make(chan struct{}, 1),
+		ctx:         ctx,
+		cancel:      cancel,
+		client:      client,
+		oldnew:      oldnew,
+		logReplacer: strings.NewReplacer(oldnew...),
 		state: &runnerv1.TaskState{
 			Id: task.Id,
 		},
@@ -99,13 +78,6 @@ func NewReporter(ctx context.Context, cancel context.CancelFunc, client client.C
 	return rv
 }

-// Result returns the final job result. Safe to call after Close() returns.
-func (r *Reporter) Result() runnerv1.Result {
-	r.stateMu.RLock()
-	defer r.stateMu.RUnlock()
-	return r.state.Result
-}
-
 func (r *Reporter) ResetSteps(l int) {
 	r.stateMu.Lock()
 	defer r.stateMu.Unlock()
@@ -116,6 +88,13 @@ func (r *Reporter) ResetSteps(l int) {
 	}
 }

+func (r *Reporter) SetStepIdMapping(stepIDs ...string) {
+	r.ResetSteps(len(stepIDs))
+	r.stateMu.Lock()
+	defer r.stateMu.Unlock()
+	r.stepIds = stepIDs
+}
+
 func (r *Reporter) Levels() []log.Level {
 	return log.AllLevels
 }
@@ -139,42 +118,11 @@ func isJobStepEntry(entry *log.Entry) bool {
 	return true
 }

-// notifyLog sends a non-blocking signal that new log rows are available.
-func (r *Reporter) notifyLog() {
-	select {
-	case r.logNotify <- struct{}{}:
-	default:
-	}
-}
-
-// notifyState sends a non-blocking signal that a UX-critical state change occurred (step start/stop, job result).
-func (r *Reporter) notifyState() {
-	select {
-	case r.stateNotify <- struct{}{}:
-	default:
-	}
-}
-
-// unlockAndNotify releases stateMu and sends channel notifications.
-// Must be called with stateMu held.
-func (r *Reporter) unlockAndNotify(urgentState bool) {
-	r.stateMu.Unlock()
-	r.notifyLog()
-	if urgentState {
-		r.notifyState()
-	}
-}
-
 func (r *Reporter) Fire(entry *log.Entry) error {
-	urgentState := false
-
 	r.stateMu.Lock()
+	defer r.stateMu.Unlock()

-	r.stateChanged = true
-
-	if log.IsLevelEnabled(log.TraceLevel) {
-		log.WithFields(entry.Data).Trace(entry.Message)
-	}
+	log.WithFields(entry.Data).Trace(entry.Message)

 	timestamp := entry.Time
 	if r.state.StartedAt == nil {
@@ -197,13 +145,11 @@ func (r *Reporter) Fire(entry *log.Entry) error {
 						}
 					}
 				}
-				urgentState = true
 			}
 		}
 		if !r.duringSteps() {
 			r.logRows = appendIfNotNil(r.logRows, r.parseLogRow(entry))
 		}
-		r.unlockAndNotify(urgentState)
 		return nil
 	}

@@ -212,18 +158,22 @@ func (r *Reporter) Fire(entry *log.Entry) error {
 		if v, ok := v.(int); ok && len(r.state.Steps) > v {
 			step = r.state.Steps[v]
 		}
+	} else if v, ok := entry.Data["stepID"]; ok {
+		if v, ok := v.([]string); ok && len(v) >= 1 {
+			if no := slices.Index(r.stepIds, v[0]); no >= 0 && len(r.state.Steps) > no {
+				step = r.state.Steps[no]
+			}
+		}
 	}
 	if step == nil {
 		if !r.duringSteps() {
 			r.logRows = appendIfNotNil(r.logRows, r.parseLogRow(entry))
 		}
-		r.unlockAndNotify(false)
 		return nil
 	}

 	if step.StartedAt == nil {
 		step.StartedAt = timestamppb.New(timestamp)
-		urgentState = true
 	}

 	// Force reporting log errors as raw output to prevent silent failures
@@ -251,91 +201,26 @@ func (r *Reporter) Fire(entry *log.Entry) error {
 			}
 			step.Result = stepResult
 			step.StoppedAt = timestamppb.New(timestamp)
-			urgentState = true
 		}
 	}

-	r.unlockAndNotify(urgentState)
 	return nil
 }

 func (r *Reporter) RunDaemon() {
-	go r.runDaemonLoop()
-}
-
-func (r *Reporter) stopLatencyTimer(active *bool, timer *time.Timer) {
-	if *active {
-		if !timer.Stop() {
-			select {
-			case <-timer.C:
-			default:
-			}
-		}
-		*active = false
+	r.stateMu.RLock()
+	closed := r.closed
+	r.stateMu.RUnlock()
+	if closed || r.ctx.Err() != nil {
+		// Acknowledge close
+		close(r.daemon)
+		return
 	}
-}

-func (r *Reporter) runDaemonLoop() {
-	logTicker := time.NewTicker(r.logReportInterval)
-	stateTicker := time.NewTicker(r.stateReportInterval)
+	_ = r.ReportLog(false)
+	_ = r.ReportState(false)

-	// maxLatencyTimer ensures the first buffered log row is sent within logReportMaxLatency.
-	// Start inactive — it is armed when the first log row arrives in an empty buffer.
-	maxLatencyTimer := time.NewTimer(0)
-	if !maxLatencyTimer.Stop() {
-		<-maxLatencyTimer.C
-	}
-	maxLatencyActive := false
-
-	defer logTicker.Stop()
-	defer stateTicker.Stop()
-	defer maxLatencyTimer.Stop()
-
-	for {
-		select {
-		case <-logTicker.C:
-			_ = r.ReportLog(false)
-			r.stopLatencyTimer(&maxLatencyActive, maxLatencyTimer)
-
-		case <-stateTicker.C:
-			_ = r.ReportState(false)
-
-		case <-r.logNotify:
-			r.stateMu.RLock()
-			n := len(r.logRows)
-			r.stateMu.RUnlock()
-
-			if n >= r.logBatchSize {
-				_ = r.ReportLog(false)
-				r.stopLatencyTimer(&maxLatencyActive, maxLatencyTimer)
-			} else if !maxLatencyActive && n > 0 {
-				maxLatencyTimer.Reset(r.logReportMaxLatency)
-				maxLatencyActive = true
-			}
-
-		case <-r.stateNotify:
-			// Step transition or job result — flush both immediately for frontend UX.
-			_ = r.ReportLog(false)
-			_ = r.ReportState(false)
-			r.stopLatencyTimer(&maxLatencyActive, maxLatencyTimer)
-
-		case <-maxLatencyTimer.C:
-			maxLatencyActive = false
-			_ = r.ReportLog(false)
-
-		case <-r.ctx.Done():
-			close(r.daemon)
-			return
-		}
-
-		r.stateMu.RLock()
-		closed := r.closed
-		r.stateMu.RUnlock()
-		if closed {
-			close(r.daemon)
-			return
-		}
-	}
+	time.AfterFunc(time.Second, r.RunDaemon)
 }

 func (r *Reporter) Logf(format string, a ...any) {
@@ -399,10 +284,6 @@ func (r *Reporter) Close(lastWords string) error {
 		})
 	}
 	r.stateMu.Unlock()
-
-	// Wake up the daemon loop so it detects closed promptly.
-	r.notifyLog()
-
 	// Wait for Acknowledge
 	select {
 	case <-r.daemon:
@@ -430,24 +311,15 @@ func (r *Reporter) ReportLog(noMore bool) error {
 	rows := r.logRows
 	r.stateMu.RUnlock()

-	if !noMore && len(rows) == 0 {
-		return nil
-	}
-
-	start := time.Now()
 	resp, err := r.client.UpdateLog(r.ctx, connect.NewRequest(&runnerv1.UpdateLogRequest{
 		TaskId: r.state.Id,
 		Index:  int64(r.logOffset),
 		Rows:   rows,
 		NoMore: noMore,
 	}))
-	metrics.ReportLogDuration.Observe(time.Since(start).Seconds())
 	if err != nil {
-		metrics.ReportLogTotal.WithLabelValues(metrics.LabelResultError).Inc()
-		metrics.ClientErrors.WithLabelValues(metrics.LabelMethodUpdateLog).Inc()
 		return err
 	}
-	metrics.ReportLogTotal.WithLabelValues(metrics.LabelResultSuccess).Inc()

 	ack := int(resp.Msg.AckIndex)
 	if ack < r.logOffset {
@@ -458,12 +330,7 @@ func (r *Reporter) ReportLog(noMore bool) error {
 	r.logRows = r.logRows[ack-r.logOffset:]
 	submitted := r.logOffset + len(rows)
 	r.logOffset = ack
-	remaining := len(r.logRows)
 	r.stateMu.Unlock()
-	if remaining != r.lastLogBufferRows {
-		metrics.ReportLogBufferRows.Set(float64(remaining))
-		r.lastLogBufferRows = remaining
-	}

 	if noMore && ack < submitted {
 		return errors.New("not all logs are submitted")
@@ -478,7 +345,15 @@ func (r *Reporter) ReportState(reportResult bool) error {
 	r.clientM.Lock()
 	defer r.clientM.Unlock()

-	// Build the outputs map first (single Range pass instead of two).
+	r.stateMu.RLock()
+	state := proto.Clone(r.state).(*runnerv1.TaskState)
+	r.stateMu.RUnlock()
+
+	// Only report result from Close to reliable sent logs
+	if !reportResult {
+		state.Result = runnerv1.Result_RESULT_UNSPECIFIED
+	}
+
 	outputs := make(map[string]string)
 	r.outputs.Range(func(k, v any) bool {
 		if val, ok := v.(string); ok {
@@ -487,36 +362,13 @@ func (r *Reporter) ReportState(reportResult bool) error {
 		return true
 	})

-	// Consume stateChanged atomically with the snapshot; restored on error
-	// below so a concurrent Fire() during UpdateTask isn't silently lost.
-	r.stateMu.Lock()
-	if !reportResult && !r.stateChanged && len(outputs) == 0 {
-		r.stateMu.Unlock()
-		return nil
-	}
-	state := proto.Clone(r.state).(*runnerv1.TaskState)
-	r.stateChanged = false
-	r.stateMu.Unlock()
-
-	if !reportResult {
-		state.Result = runnerv1.Result_RESULT_UNSPECIFIED
-	}
-
-	start := time.Now()
 	resp, err := r.client.UpdateTask(r.ctx, connect.NewRequest(&runnerv1.UpdateTaskRequest{
 		State:   state,
 		Outputs: outputs,
 	}))
-	metrics.ReportStateDuration.Observe(time.Since(start).Seconds())
 	if err != nil {
-		metrics.ReportStateTotal.WithLabelValues(metrics.LabelResultError).Inc()
-		metrics.ClientErrors.WithLabelValues(metrics.LabelMethodUpdateTask).Inc()
-		r.stateMu.Lock()
-		r.stateChanged = true
-		r.stateMu.Unlock()
 		return err
 	}
-	metrics.ReportStateTotal.WithLabelValues(metrics.LabelResultSuccess).Inc()

 	for _, k := range resp.Msg.SentOutputs {
 		r.outputs.Store(k, struct{}{})
--- a/internal/pkg/report/reporter_test.go
+++ b/internal/pkg/report/reporter_test.go
@@ -6,15 +6,11 @@ package report
 import (
 	"context"
 	"errors"
-	"fmt"
 	"strings"
-	"sync/atomic"
+	"sync"
 	"testing"
 	"time"

-	"gitea.com/gitea/act_runner/internal/pkg/client/mocks"
-	"gitea.com/gitea/act_runner/internal/pkg/config"
-
 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
 	connect_go "connectrpc.com/connect"
 	log "github.com/sirupsen/logrus"
@@ -23,6 +19,8 @@ import (
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/structpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"gitea.com/gitea/act_runner/internal/pkg/client/mocks"
 )

 func TestReporter_parseLogRow(t *testing.T) {
@@ -177,10 +175,9 @@ func TestReporter_Fire(t *testing.T) {
 		ctx, cancel := context.WithCancel(context.Background())
 		taskCtx, err := structpb.NewStruct(map[string]any{})
 		require.NoError(t, err)
-		cfg, _ := config.LoadDefault("")
 		reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{
 			Context: taskCtx,
-		}, cfg)
+		})
 		reporter.RunDaemon()
 		defer func() {
 			require.NoError(t, reporter.Close(""))
@@ -255,8 +252,7 @@ func TestReporter_EphemeralRunnerDeletion(t *testing.T) {
 	defer cancel()
 	taskCtx, err := structpb.NewStruct(map[string]any{})
 	require.NoError(t, err)
-	cfg, _ := config.LoadDefault("")
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
+	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx})
 	reporter.ResetSteps(1)

 	// Fire a log entry to create pending data
@@ -319,281 +315,23 @@ func TestReporter_RunDaemonClose_Race(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	taskCtx, err := structpb.NewStruct(map[string]any{})
 	require.NoError(t, err)
-	cfg, _ := config.LoadDefault("")
 	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{
 		Context: taskCtx,
-	}, cfg)
+	})
 	reporter.ResetSteps(1)

-	// Start the daemon loop — RunDaemon spawns a goroutine internally.
-	reporter.RunDaemon()
+	// Start the daemon loop in a separate goroutine.
+	// RunDaemon reads r.closed and reschedules itself via time.AfterFunc.
+	var wg sync.WaitGroup
+	wg.Go(func() {
+		reporter.RunDaemon()
+	})

-	// Close concurrently — this races with the daemon goroutine on r.closed.
+	// Close concurrently — this races with RunDaemon on r.closed.
 	require.NoError(t, reporter.Close(""))

-	// Cancel context so the daemon goroutine exits cleanly.
+	// Cancel context so pending AfterFunc callbacks exit quickly.
 	cancel()
-}
-
-// TestReporter_MaxLatencyTimer verifies that the maxLatencyTimer flushes a
-// single buffered log row before the periodic logTicker fires.
-//
-// Setup: logReportInterval=10s (effectively never), maxLatency=100ms.
-// Fire one log line, then assert UpdateLog is called within 500ms.
-func TestReporter_MaxLatencyTimer(t *testing.T) {
-	var updateLogCalls atomic.Int64
-
-	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			updateLogCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
-		},
-	)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
-		},
-	)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	taskCtx, err := structpb.NewStruct(map[string]any{})
-	require.NoError(t, err)
-
-	// Custom config: logTicker=10s (won't fire during test), maxLatency=100ms
-	cfg, _ := config.LoadDefault("")
-	cfg.Runner.LogReportInterval = 10 * time.Second
-	cfg.Runner.LogReportMaxLatency = 100 * time.Millisecond
-	cfg.Runner.LogReportBatchSize = 1000 // won't trigger batch flush
-
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
-	reporter.ResetSteps(1)
-	reporter.RunDaemon()
-	defer func() {
-		_ = reporter.Close("")
-	}()
-
-	// Fire a single log line — not enough to trigger batch flush
-	require.NoError(t, reporter.Fire(&log.Entry{
-		Message: "single log line",
-		Data:    log.Fields{"stage": "Main", "stepNumber": 0, "raw_output": true},
-	}))
-
-	// maxLatencyTimer should flush within ~100ms. Wait up to 500ms.
-	assert.Eventually(t, func() bool {
-		return updateLogCalls.Load() > 0
-	}, 500*time.Millisecond, 10*time.Millisecond,
-		"maxLatencyTimer should have flushed the log before logTicker (10s)")
-}
-
-// TestReporter_BatchSizeFlush verifies that reaching logBatchSize triggers
-// an immediate log flush without waiting for any timer.
-func TestReporter_BatchSizeFlush(t *testing.T) {
-	var updateLogCalls atomic.Int64
-
-	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			updateLogCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
-		},
-	)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
-		},
-	)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	taskCtx, err := structpb.NewStruct(map[string]any{})
-	require.NoError(t, err)
-
-	// Custom config: large timers, small batch size
-	cfg, _ := config.LoadDefault("")
-	cfg.Runner.LogReportInterval = 10 * time.Second
-	cfg.Runner.LogReportMaxLatency = 10 * time.Second
-	cfg.Runner.LogReportBatchSize = 5
-
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
-	reporter.ResetSteps(1)
-	reporter.RunDaemon()
-	defer func() {
-		_ = reporter.Close("")
-	}()
-
-	// Fire exactly batchSize log lines
-	for i := range 5 {
-		require.NoError(t, reporter.Fire(&log.Entry{
-			Message: fmt.Sprintf("log line %d", i),
-			Data:    log.Fields{"stage": "Main", "stepNumber": 0, "raw_output": true},
-		}))
-	}
-
-	// Batch threshold should trigger immediate flush
-	assert.Eventually(t, func() bool {
-		return updateLogCalls.Load() > 0
-	}, 500*time.Millisecond, 10*time.Millisecond,
-		"batch size threshold should have triggered immediate flush")
-}
-
-// TestReporter_StateChangedNotLostDuringReport asserts that a Fire() arriving
-// mid-UpdateTask re-dirties the flag so the change is picked up by the next report.
-func TestReporter_StateChangedNotLostDuringReport(t *testing.T) {
-	var updateTaskCalls atomic.Int64
-	inFlight := make(chan struct{})
-	release := make(chan struct{})
-
-	client := mocks.NewClient(t)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			n := updateTaskCalls.Add(1)
-			if n == 1 {
-				// Signal that the first UpdateTask is in flight, then block until released.
-				close(inFlight)
-				<-release
-			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
-		},
-	)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	taskCtx, err := structpb.NewStruct(map[string]any{})
-	require.NoError(t, err)
-	cfg, _ := config.LoadDefault("")
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
-	reporter.ResetSteps(2)
-
-	// Mark stateChanged=true so the first ReportState proceeds to UpdateTask.
-	reporter.stateMu.Lock()
-	reporter.stateChanged = true
-	reporter.stateMu.Unlock()
-
-	// Kick off the first ReportState in a goroutine — it will block in UpdateTask.
-	done := make(chan error, 1)
-	go func() {
-		done <- reporter.ReportState(false)
-	}()
-
-	// Wait until UpdateTask is in flight (snapshot taken, flag consumed).
-	<-inFlight
-
-	// Concurrent Fire() modifies state — must re-flip stateChanged so the
-	// change is not lost when the in-flight ReportState finishes.
-	require.NoError(t, reporter.Fire(&log.Entry{
-		Message: "step starts",
-		Data:    log.Fields{"stage": "Main", "stepNumber": 1, "raw_output": true},
-	}))
-
-	// Release the in-flight UpdateTask and wait for it to return.
-	close(release)
-	require.NoError(t, <-done)
-
-	// stateChanged must still be true so the next ReportState picks up the
-	// concurrent Fire()'s change instead of skipping via the early-return path.
-	reporter.stateMu.RLock()
-	changed := reporter.stateChanged
-	reporter.stateMu.RUnlock()
-	assert.True(t, changed, "stateChanged must remain true after a concurrent Fire() during in-flight ReportState")
-
-	// And the next ReportState must actually send a second UpdateTask.
-	require.NoError(t, reporter.ReportState(false))
-	assert.Equal(t, int64(2), updateTaskCalls.Load(), "concurrent Fire() change must trigger a second UpdateTask, not be silently lost")
-}
-
-// TestReporter_StateChangedRestoredOnError verifies that when UpdateTask fails,
-// the dirty flag is restored so the snapshotted change isn't silently lost.
-func TestReporter_StateChangedRestoredOnError(t *testing.T) {
-	var updateTaskCalls atomic.Int64
-
-	client := mocks.NewClient(t)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			n := updateTaskCalls.Add(1)
-			if n == 1 {
-				return nil, errors.New("transient network error")
-			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
-		},
-	)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	taskCtx, err := structpb.NewStruct(map[string]any{})
-	require.NoError(t, err)
-	cfg, _ := config.LoadDefault("")
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
-	reporter.ResetSteps(1)
-
-	reporter.stateMu.Lock()
-	reporter.stateChanged = true
-	reporter.stateMu.Unlock()
-
-	// First ReportState fails — flag must be restored to true.
-	require.Error(t, reporter.ReportState(false))
-
-	reporter.stateMu.RLock()
-	changed := reporter.stateChanged
-	reporter.stateMu.RUnlock()
-	assert.True(t, changed, "stateChanged must be restored to true after UpdateTask error so the change is retried")
-
-	// The next ReportState should still issue a request because the flag was restored.
-	require.NoError(t, reporter.ReportState(false))
-	assert.Equal(t, int64(2), updateTaskCalls.Load())
-}
-
-// TestReporter_StateNotifyFlush verifies that step transitions trigger
-// an immediate state flush via the stateNotify channel.
-func TestReporter_StateNotifyFlush(t *testing.T) {
-	var updateTaskCalls atomic.Int64
-
-	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
-		},
-	)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			updateTaskCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
-		},
-	)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	taskCtx, err := structpb.NewStruct(map[string]any{})
-	require.NoError(t, err)
-
-	// Custom config: large state interval so only stateNotify can trigger
-	cfg, _ := config.LoadDefault("")
-	cfg.Runner.StateReportInterval = 10 * time.Second
-	cfg.Runner.LogReportInterval = 10 * time.Second
-
-	reporter := NewReporter(ctx, cancel, client, &runnerv1.Task{Context: taskCtx}, cfg)
-	reporter.ResetSteps(1)
-	reporter.RunDaemon()
-	defer func() {
-		_ = reporter.Close("")
-	}()
-
-	// Fire a log entry that starts a step — this triggers stateNotify
-	require.NoError(t, reporter.Fire(&log.Entry{
-		Message: "step starting",
-		Data:    log.Fields{"stage": "Main", "stepNumber": 0, "raw_output": true},
-	}))
-
-	// stateNotify should trigger immediate UpdateTask call
-	assert.Eventually(t, func() bool {
-		return updateTaskCalls.Load() > 0
-	}, 500*time.Millisecond, 10*time.Millisecond,
-		"step transition should have triggered immediate state flush via stateNotify")
+	wg.Wait()
+	time.Sleep(2 * time.Second)
 }
Author	SHA1	Message	Date
Christopher Homberger	52eb6e43cd	Merge branch 'main' of gitea.com:gitea/act_runner into act-runner-actions-oss-act	2026-02-22 20:26:32 +01:00
Christopher Homberger	b48c9c29e9	Merge branch 'act-runner-actions-oss-act' of gitea.com:gitea/act_runner into act-runner-actions-oss-act	2026-02-22 17:34:49 +01:00
Christopher Homberger	cfbb124754	Move logging to another file	2026-02-22 17:34:18 +01:00
Christopher Homberger	340e1de2e3	fix GitHubAPIServerURL	2026-02-22 17:28:48 +01:00
silverwind	f98673129b	Merge branch 'main' into act-runner-actions-oss-act	2026-02-22 15:07:57 +00:00
Christopher Homberger	3f008b3310	forget needs	2026-02-22 16:05:39 +01:00
Christopher Homberger	9f7b881426	fix lint	2026-02-22 15:51:52 +01:00
Christopher Homberger	0ab72505cc	Merge branch 'main' of gitea.com:gitea/act_runner into act-runner-actions-oss-act	2026-02-22 15:45:00 +01:00
Christopher Homberger	d4c46e538e	add strategy	2026-02-20 21:44:30 +01:00
Christopher Homberger	ae82ca2e97	adapt	2026-02-20 21:37:36 +01:00
Christopher Homberger	d9948c0df4	fix add more ctx	2026-02-20 21:10:28 +01:00
Christopher Homberger	995551f1aa	experiment	2026-02-20 21:10:28 +01:00
Christopher Homberger	579b7af04f	wip update go mod	2026-02-20 21:10:16 +01:00
Christopher Homberger	17bc93f003	migrate to WithJobLoggerFactory	2026-02-20 14:17:04 +01:00
Christopher Homberger	35df5a61e4	WIP evaluate upgrade	2026-02-20 14:10:55 +01:00