fix: reduce idle runner polling by default

Raise the default idle fetch backoff ceiling to reduce steady-state FetchTask traffic from idle runner fleets while keeping the value configurable for installations that need faster idle polling.

Fixes: https://gitea.com/gitea/runner/issues/762

Co-Authored-By: GPT-5 Codex <codex@openai.com>

.gitea/workflows/pull-pr-title.yml

@@ -18,8 +18,8 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+    - uses: actions/checkout@v7
-    - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7
+    - uses: actions/setup-node@v6
       with:
         node-version: 24
     - run: make lint-pr-title

.gitea/workflows/release-nightly.yml

@@ -17,26 +17,14 @@ jobs:
   goreleaser:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
-      # Custom publishers (the R2 mirror below) run as the very last
+      - uses: actions/setup-go@v6
-      # step of goreleaser's publish pipeline, after the Gitea release
-      # has already been created and every artifact already uploaded
-      # to S3. Fail here instead, before anything is built or
-      # published, if the R2 secrets are missing.
-      - name: check R2 configuration
-        run: sh scripts/upload-r2.sh --check-config
-        env:
-          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
-          R2_BUCKET: ${{ secrets.R2_BUCKET }}
-          R2_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
-          R2_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
         with:
           go-version-file: "go.mod"
       - name: goreleaser
-        uses: goreleaser/goreleaser-action@f06c13b6b1a9625abc9e6e439d9c05a8f2190e94 # v7
+        uses: goreleaser/goreleaser-action@v7
         with:
           distribution: goreleaser-pro
           args: release --nightly
@@ -47,10 +35,6 @@ jobs:
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           S3_REGION: ${{ secrets.AWS_REGION }}
           S3_BUCKET: ${{ secrets.AWS_BUCKET }}
-          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
-          R2_BUCKET: ${{ secrets.R2_BUCKET }}
-          R2_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
-          R2_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
           GORELEASER_FORCE_TOKEN: "gitea"
           GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -59,33 +43,27 @@ jobs:
     strategy:
       matrix:
         variant:
-          # The basic image is built from source and can target any arch the
-          # toolchain supports. The dind variants are limited to the arches the
-          # docker:dind base image publishes.
           - target: basic
             tag_suffix: ""
-            platforms: linux/amd64,linux/arm64,linux/riscv64,linux/s390x
           - target: dind
             tag_suffix: "-dind"
-            platforms: linux/amd64,linux/arm64
           - target: dind-rootless
             tag_suffix: "-dind-rootless"
-            platforms: linux/amd64,linux/arm64
 
     steps:
       - name: Checkout
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0 # all history for all branches and tags
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4
+        uses: docker/setup-qemu-action@v4
 
       - name: Set up Docker BuildX
-        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4
+        uses: docker/setup-buildx-action@v4
 
       - name: Login to DockerHub
-        uses: docker/login-action@abd2ef45e78c5afb21d64d4ca52ee8550d9572c7 # v4
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
@@ -99,12 +77,14 @@ jobs:
           echo REPO_VERSION=$(git describe --tags --always | sed 's/-/+/' | sed 's/^v//') >> $GITHUB_OUTPUT
 
       - name: Build and push
-        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7
+        uses: docker/build-push-action@v7
         with:
           context: .
           file: ./Dockerfile
           target: ${{ matrix.variant.target }}
-          platforms: ${{ matrix.variant.platforms }}
+          platforms: |
+            linux/amd64
+            linux/arm64
           push: true
           tags: |
             ${{ env.DOCKER_ORG }}/runner:nightly${{ matrix.variant.tag_suffix }}

.gitea/workflows/release-tag.yml

@@ -9,33 +9,21 @@ jobs:
   goreleaser:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0 # all history for all branches and tags
-      # Custom publishers (the R2 mirror below) run as the very last
+      - uses: actions/setup-go@v6
-      # step of goreleaser's publish pipeline, after the Gitea release
-      # has already been created and every artifact already uploaded
-      # to S3. Fail here instead, before anything is built or
-      # published, if the R2 secrets are missing.
-      - name: check R2 configuration
-        run: sh scripts/upload-r2.sh --check-config
-        env:
-          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
-          R2_BUCKET: ${{ secrets.R2_BUCKET }}
-          R2_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
-          R2_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
         with:
           go-version-file: "go.mod"
       - name: Import GPG key
         id: import_gpg
-        uses: crazy-max/ghaction-import-gpg@2dc316deee8e90f13e1a351ab510b4d5bc0c82cd # v7
+        uses: crazy-max/ghaction-import-gpg@v7
         with:
           gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
           passphrase: ${{ secrets.PASSPHRASE }}
           fingerprint: CC64B1DB67ABBEECAB24B6455FC346329753F4B0
       - name: goreleaser
-        uses: goreleaser/goreleaser-action@f06c13b6b1a9625abc9e6e439d9c05a8f2190e94 # v7
+        uses: goreleaser/goreleaser-action@v7
         with:
           distribution: goreleaser-pro
           args: release
@@ -46,10 +34,6 @@ jobs:
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           S3_REGION: ${{ secrets.AWS_REGION }}
           S3_BUCKET: ${{ secrets.AWS_BUCKET }}
-          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
-          R2_BUCKET: ${{ secrets.R2_BUCKET }}
-          R2_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
-          R2_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
           GORELEASER_FORCE_TOKEN: "gitea"
           GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           GPG_FINGERPRINT: ${{ steps.import_gpg.outputs.fingerprint }}
@@ -58,18 +42,12 @@ jobs:
     strategy:
       matrix:
         variant:
-          # The basic image is built from source and can target any arch the
-          # toolchain supports. The dind variants are limited to the arches the
-          # docker:dind base image publishes.
           - target: basic
             tag_suffix: ""
-            platforms: linux/amd64,linux/arm64,linux/riscv64,linux/s390x
           - target: dind
             tag_suffix: "-dind"
-            platforms: linux/amd64,linux/arm64
           - target: dind-rootless
             tag_suffix: "-dind-rootless"
-            platforms: linux/amd64,linux/arm64
     container:
       image: catthehacker/ubuntu:act-latest
     env:
@@ -77,25 +55,25 @@ jobs:
       DOCKER_LATEST: latest
     steps:
       - name: Checkout
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0 # all history for all branches and tags
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4
+        uses: docker/setup-qemu-action@v4
 
       - name: Set up Docker BuildX
-        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4
+        uses: docker/setup-buildx-action@v4
 
       - name: Login to DockerHub
-        uses: docker/login-action@abd2ef45e78c5afb21d64d4ca52ee8550d9572c7 # v4
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: "Docker meta"
         id: docker_meta
-        uses: docker/metadata-action@dc802804100637a589fabce1cb79ff13a1411302 # v6
+        uses: docker/metadata-action@v6
         with:
           images: |
             ${{ env.DOCKER_ORG }}/runner
@@ -108,12 +86,14 @@ jobs:
             suffix=${{ matrix.variant.tag_suffix }},onlatest=true
 
       - name: Build and push
-        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7
+        uses: docker/build-push-action@v7
         with:
           context: .
           file: ./Dockerfile
           target: ${{ matrix.variant.target }}
-          platforms: ${{ matrix.variant.platforms }}
+          platforms: |
+            linux/amd64
+            linux/arm64
           push: true
           tags: ${{ steps.docker_meta.outputs.tags }}
           build-args: |

.gitea/workflows/test.yml

@@ -17,8 +17,8 @@ jobs:
       # to ~/.docker with the stale credentials.
       DOCKER_CONFIG: /tmp/docker-noauth
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v7
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
+      - uses: actions/setup-go@v6
         with:
           go-version-file: 'go.mod'
       - name: prepare anonymous docker config
@@ -33,8 +33,6 @@ jobs:
           done
       - name: lint
         run: make lint
-      - name: checks
-        run: make checks
       - name: build
         run: make build
       - name: test

.golangci.yml

@@ -11,7 +11,6 @@ linters:
     - dupl
     - errcheck
     - forbidigo
-    - forcetypeassert
     - gocheckcompilerdirectives
     - gocritic
     - goheader
@@ -103,9 +102,6 @@ linters:
       - linters:
           - forbidigo
         path: cmd
-      - linters:
-          - forcetypeassert
-        path: _test\.go
 issues:
   max-issues-per-linter: 0
   max-same-issues: 0

.goreleaser.yaml

@@ -93,37 +93,6 @@ blobs:
       - glob: ./**.xz
       - glob: ./**.sha256
 
-# Mirrors the S3 `blobs:` upload above into Cloudflare R2 during the
-# parallel S3+R2 period (S3 will be removed once migration completes).
-# A second `blobs:` entry is impossible here since the blob pipe
-# authenticates from the global AWS_* env with no per-entry
-# credentials; `publishers:` supports per-entry `env:` instead, so
-# it's used to invoke scripts/upload-r2.sh once per artifact. Custom
-# publishers inherit almost nothing from the environment, hence the
-# explicit R2_* forwarding below.
-#
-# This publisher fires 109 times for 73 distinct keys because
-# goreleaser's release pipe already registers `release.extra_files`
-# as UploadableFile artifacts, and `internal/exec`'s filterArtifacts
-# appends this block's own extra_files with no de-duplication. It
-# can't be globbed away, since gobwas/glob (via goreleaser/fileglob)
-# has no substring-exclusion matcher. It's harmless: PUT is
-# idempotent, and the `./**.xz` glob below is kept deliberately so
-# this publisher declares its own complete file set rather than
-# implicitly depending on the `release:` block's globs.
-publishers:
-  - name: cloudflare-r2
-    checksum: true
-    extra_files:
-      - glob: ./**.xz
-      - glob: ./**.sha256
-    cmd: sh scripts/upload-r2.sh {{ abs .ArtifactPath }} gitea-runner/{{ .Version }}/{{ .ArtifactName }}
-    env:
-      - R2_ENDPOINT={{ index .Env "R2_ENDPOINT" }}
-      - R2_BUCKET={{ index .Env "R2_BUCKET" }}
-      - R2_ACCESS_KEY_ID={{ index .Env "R2_ACCESS_KEY_ID" }}
-      - R2_SECRET_ACCESS_KEY={{ index .Env "R2_SECRET_ACCESS_KEY" }}
-
 archives:
   - format: binary
     name_template: "{{ .Binary }}"

Dockerfile

@@ -17,7 +17,7 @@ RUN make clean && make build
 ### DIND VARIANT
 #
 #
-FROM docker:29.6.2-dind AS dind
+FROM docker:29.6.1-dind AS dind
 
 ARG VERSION=dev
 
@@ -37,7 +37,7 @@ ENTRYPOINT ["s6-svscan","/etc/s6"]
 ### DIND-ROOTLESS VARIANT
 #
 #
-FROM docker:29.6.2-dind-rootless AS dind-rootless
+FROM docker:29.6.1-dind-rootless AS dind-rootless
 
 ARG VERSION=dev
 

Makefile

@@ -21,8 +21,6 @@ DOCKER_ROOTLESS_REF := $(DOCKER_IMAGE):$(DOCKER_TAG)-dind-rootless
 GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2
 GOVULNCHECK_PACKAGE ?= golang.org/x/vuln/cmd/govulncheck@v1.3.0
 
-GOTEST_FLAGS ?= -race -timeout 20m -parallel 8
-
 STATIC ?=
 EXTLDFLAGS ?=
 ifneq ($(STATIC),)
@@ -112,9 +110,6 @@ deps-tools: ## install tool dependencies
 	$(GO) install $(GOVULNCHECK_PACKAGE) & \
 	wait
 
-.PHONY: checks
-checks: tidy-check fmt-check security-check ## run the non-lint source checks
-
 .PHONY: lint
 lint: lint-go lint-go-windows ## lint everything
 
@@ -136,7 +131,7 @@ lint-pr-title: ## lint PR title against Conventional Commits (set PR_TITLE=...)
 	@node ./tools/lint-pr-title.ts
 
 .PHONY: security-check
-security-check:
+security-check: deps-tools
 	GOEXPERIMENT= $(GO) run $(GOVULNCHECK_PACKAGE) -show color ./... || true
 
 .PHONY: tidy
@@ -153,8 +148,8 @@ tidy-check: tidy
 	fi
 
 .PHONY: test
-test: ## test everything (integration tests self-skip without docker/network)
+test: fmt-check security-check ## test everything (integration tests self-skip without docker/network)
-	@$(GO) test $(GOTEST_FLAGS) -cover -coverprofile coverage.txt ./... && echo "\n==>\033[32m Ok\033[m\n" || exit 1
+	@$(GO) test -race -timeout 20m -v -cover -coverprofile coverage.txt ./... && echo "\n==>\033[32m Ok\033[m\n" || exit 1
 
 .PHONY: coverage-report
 coverage-report: ## turn coverage.txt from `make test` into .tmp/coverage.md

README.md

@@ -85,8 +85,6 @@ docker run -e GITEA_INSTANCE_URL=https://your_gitea.com -e GITEA_RUNNER_REGISTRA
 
 Mount a volume on `/data` if you want the registration file and optional config to survive container recreation (see [scripts/run.sh](scripts/run.sh)).
 
-> **`/data` does not hold the image cache.** It is the runner's working directory and contains only the `.runner` registration file and, optionally, your config file. Images pulled for jobs live in the *Docker daemon's* data root, which for the `dind` flavours is inside the container (`/var/lib/docker`, or `/home/rootless/.local/share/docker` for `dind-rootless`). To keep the image cache across restarts, give that path its own volume as well — otherwise every new container re-pulls the job images. With the `basic` flavour the images live on whichever daemon you point the runner at, so there is nothing extra to persist.
-
 ### Image flavours
 
 The image is published in three flavours, all built from the single multi-stage [Dockerfile](Dockerfile) in this repository. They differ only in how a Docker daemon is made available to the jobs the runner executes; the `gitea-runner` binary inside them is identical.
@@ -123,8 +121,6 @@ Two processes have to run side by side here (the Docker daemon and the runner),
 
 Same idea as `dind`, but built on `docker:dind-rootless` so the bundled daemon and the runner run as an unprivileged user (`rootless`, UID 1000) rather than `root`. `DOCKER_HOST` is preset to `unix:///run/user/1000/docker.sock` so the runner talks to the rootless daemon. This reduces the blast radius compared to the privileged `dind` flavour, but rootless Docker carries the usual rootless limitations (networking, cgroups, storage drivers, and some operations that need additional host configuration such as `/etc/subuid` / `/etc/subgid` mappings and unprivileged user-namespace support).
 
-> **The UID is fixed at 1000.** It comes from the `rootless` user baked into the upstream `docker:dind-rootless` base image, and the bundled daemon always listens on `/run/user/1000/docker.sock` inside the container, so running this flavour as a different user (`--user 1001`) does not work. If you need the runner to talk to a *host* rootless daemon that runs under some other UID, use the `basic` flavour instead and bind-mount that daemon's socket (see [examples/vm/rootless-docker.md](examples/vm/rootless-docker.md)); pointing `DOCKER_HOST` at a host socket from inside `dind-rootless` will not work. Changing the UID otherwise means rebuilding the image from a base with a different `rootless` user.
-
 > **Note on Podman:** these images target the Docker daemon. The bundled `dind`/`dind-rootless` daemons are `dockerd`, not Podman, and the `basic` flavour expects a Docker-compatible socket. Running them under rootless Podman is not a supported configuration, though pointing the `basic` flavour at a Podman socket that emulates the Docker API may work for some workloads.
 
 ### Configuration
@@ -147,97 +143,23 @@ Every option is described in [config.example.yaml](internal/pkg/config/config.ex
 
 #### Without a config file
 
-If you omit `-c`, built-in defaults apply (same as an empty YAML document).
+If you omit `-c`, built-in defaults apply (same as an empty YAML document). A small set of **deprecated** environment variables can still override parts of that default config, but **only when no `-c` path was given**; they are ignored if you use a config file:
 
-Earlier releases let a small set of environment variables (`GITEA_DEBUG`, `GITEA_TRACE`, `GITEA_RUNNER_CAPACITY`, `GITEA_RUNNER_FILE`, `GITEA_RUNNER_ENVIRON`, `GITEA_RUNNER_ENV_FILE`) override parts of the default config. Those overrides have been removed — use a YAML config file for all settings instead. For the Docker images, the entrypoint still understands a separate set of variables (such as `RUNNER_STATE_FILE`); see [scripts/run.sh](scripts/run.sh) and the container documentation below.
+| Variable | Effect |
-
-### Labels
-
-Labels decide **which jobs a runner accepts** and **how it runs them**. A job's `runs-on` is matched against the runner's label names; the first match wins and selects the execution environment for that job.
-
-A label is written as:
-
-```text
-<name>[:<schema>[:<args>]]
-```
-
-| Part | Meaning |
 | --- | --- |
-| `name` | The name a workflow refers to in `runs-on`, e.g. `ubuntu-latest`. |
+| `GITEA_DEBUG` | If true, sets log level to `debug` |
-| `schema` | Either `docker` or `host`. Defaults to `host` when omitted. |
+| `GITEA_TRACE` | If true, sets log level to `trace` |
-| `args` | Only used by the `docker` schema: the image to run the job in. |
+| `GITEA_RUNNER_CAPACITY` | Concurrent jobs (integer) |
+| `GITEA_RUNNER_FILE` | Registration state file path (default `.runner`) |
+| `GITEA_RUNNER_ENVIRON` | Extra job env vars as comma-separated `KEY:VALUE` pairs |
+| `GITEA_RUNNER_ENV_FILE` | Path to an env file merged into job env (same idea as `runner.env_file` in YAML) |
 
-Two schemas are supported:
+Prefer a YAML file for all settings.
-
-- **`docker://<image>`** — the job runs inside a container created from `<image>`:
-
-  ```text
-  ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest
-  ```
-
-- **`host`** — the job's steps run directly on the machine the runner is on, using the tools installed there:
-
-  ```text
-  macos:host
-  ```
-
-So with the labels
-
-```text
-ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest,macos:host
-```
-
-a workflow with `runs-on: ubuntu-latest` is executed in the `runner-images:ubuntu-latest` container, and one with `runs-on: macos` is executed directly on the host.
-
-Names may themselves contain a colon (for example `pool:e57e18d4-10d4-406f-93bf-60f127221bdd`); only `host` and `docker` are treated as schemas.
-
-If a job's `runs-on` matches none of the runner's labels, the job still runs, in the default `docker.gitea.com/runner-images:ubuntu-latest` image. Images maintained for this purpose are listed at [gitea/runner-images](https://gitea.com/gitea/runner-images).
-
-Labels are chosen at registration time (`--labels`, or the interactive prompt) and can be changed afterwards by editing `runner.labels` in the config file, or in the Gitea UI under the runner's settings.
 
 #### Registration vs config labels
 
 If `runner.labels` is set in the YAML file, those labels are used during `register` and the `--labels` CLI flag is ignored.
 
-The `daemon` command also accepts `--labels` (which defaults to the `GITEA_RUNNER_LABELS` environment variable), so the labels of an already registered runner can be changed without deleting its registration file. The most explicit source wins:
-
-```
---labels / GITEA_RUNNER_LABELS   >   runner.labels in the config file   >   labels in the .runner file
-```
-
-Whenever the resulting labels differ from the ones in the registration file, they are written back to it and re-declared to the Gitea instance on startup.
-
-> **Note:** A runner that only exposes `host` labels still needs access to a Docker daemon (e.g. a mounted `/var/run/docker.sock`) whenever a job uses a `docker://` action or a service container. `host` labels only change where the job's own steps run; container-based steps and actions are still executed with Docker.
-
-#### Proxy
-
-Set these variables in the runner's environment, with systemd `Environment=`, `docker run -e`, or Kubernetes `env:`:
-
-```sh
-http_proxy=http://proxy.example:3128
-https_proxy=http://proxy.example:3128
-no_proxy=gitea.internal,.example.local
-```
-
-The runner uses them for its own requests and gives them to every job, in lower and upper case.
-
-These hosts are added to `no_proxy` for jobs, so they are always reached directly:
-
-- the cache server
-- `localhost`, `127.0.0.1` and `::1`
-- the job's service containers
-- the Docker daemon, when it is reached over `tcp://`
-
-Gitea is not added. Add it to `no_proxy` yourself if it should be reached directly.
-
-To change a value for one job, set it in a step's `env:` or in the job's `container.env`. Setting it at workflow or job level has no effect. To change it for the whole runner, set it in `runner.envs`. A `no_proxy` set there is added to the list above instead of replacing it.
-
-Images are pulled by the Docker daemon, which needs its own proxy setting. In the `dind` images the daemon runs in the same container and reads the variables above. For any other daemon, see [the Docker documentation](https://docs.docker.com/engine/daemon/proxy/). The runner logs a warning at startup if it has a proxy and the daemon does not.
-
-Dockerfile actions are built with these variables as build arguments, so their `RUN` steps can reach the network.
-
-A password in a proxy URL is hidden in job logs. Any step can still read it, because the step is given the proxy URL in its environment.
-
 #### Caching (`actions/cache`)
 
 Each runner starts its own cache server automatically. Cache entries are local to that runner — runners do not share a cache by default.
@@ -253,7 +175,6 @@ Run one dedicated `gitea-runner cache-server` that all runners point at.
      dir: /data/actcache
      port: 8088
      external_secret: "replace-with-a-strong-random-secret"
-     # external_secret_file: /path/to/secret # secret can also be passed via a file
    ```
 
 2. Start the server:
@@ -268,7 +189,6 @@ Run one dedicated `gitea-runner cache-server` that all runners point at.
    cache:
      external_server: "http://<cache-server-host>:8088/"
      external_secret: "replace-with-a-strong-random-secret"  # must match the server
-     # external_secret_file: /path/to/secret # secret can also be passed via a file
    ```
 
 Alternatively, mount the same NFS/CIFS share on every runner and point `cache.dir` at it — simpler, but with weaker isolation between repositories.
@@ -299,16 +219,6 @@ On Windows, use `.exe`, `.bat`, or `.cmd` paths; **PowerShell (`.ps1`) is not su
 
 See **[docs/post-task-script.md](docs/post-task-script.md)** for lifecycle details, environment variables, timeout interaction, and platform notes.
 
-#### Job hooks (`runner.hooks.job_started`, `runner.hooks.job_completed`)
-
-Optional scripts that run **inside the job environment** (the job container, or the host in host mode), before the job's first step and after its last one. They are the equivalent of GitHub's `ACTIONS_RUNNER_HOOK_JOB_STARTED` / `ACTIONS_RUNNER_HOOK_JOB_COMPLETED`, which are read when the settings are unset.
-
-Because they run where the steps run and see the job's environment, they are the place for per-job setup no workflow should have to carry: registry logins, mirror configuration, or masking runner-wide secrets with `::add-mask::`. Their output is part of the job log and is scanned for workflow commands, and they can export to the job through `$GITHUB_ENV` and `$GITHUB_PATH`.
-
-Both hooks are synchronous and block the job while they run. Either one exiting non-zero fails the job, and there is no per-hook timeout.
-
-See **[docs/job-hooks.md](docs/job-hooks.md)** for the execution order, environment, and platform notes.
-
 ### Example Deployments
 
 Check out the [examples](examples) directory for sample deployment types.

act/artifactcache/handler.go

@@ -70,7 +70,6 @@ type Handler struct {
 	storage  *Storage
 	router   *httprouter.Router
 	listener net.Listener
-	port     int
 	server   *http.Server
 	logger   logrus.FieldLogger
 
@@ -178,12 +177,6 @@ func StartHandler(dir, outboundIP string, port uint16, internalSecret string, lo
 	if err != nil {
 		return nil, err
 	}
-	addr, ok := listener.Addr().(*net.TCPAddr)
-	if !ok {
-		listener.Close()
-		return nil, fmt.Errorf("cache server listens on %T, want a TCP address", listener.Addr())
-	}
-	h.port = addr.Port
 	server := &http.Server{
 		ReadHeaderTimeout: 2 * time.Second,
 		Handler:           router,
@@ -201,7 +194,9 @@ func StartHandler(dir, outboundIP string, port uint16, internalSecret string, lo
 
 func (h *Handler) ExternalURL() string {
 	// TODO: make the external url configurable if necessary
-	return fmt.Sprintf("http://%s:%d", h.outboundIP, h.port)
+	return fmt.Sprintf("http://%s:%d",
+		h.outboundIP,
+		h.listener.Addr().(*net.TCPAddr).Port)
 }
 
 // RegisterJob makes token a valid bearer credential for cache requests from

act/artifactcache/handler_test.go

@@ -445,6 +445,13 @@ func TestHandler(t *testing.T) {
 		require.Equal(t, 404, resp.StatusCode)
 	})
 
+	t.Run("get with not exist id", func(t *testing.T) {
+		resp, err := testClient.Get(signArtifactURL(handler, 100))
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		require.Equal(t, 404, resp.StatusCode)
+	})
+
 	t.Run("get with multiple keys", func(t *testing.T) {
 		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
 		key := strings.ToLower(t.Name())
@@ -462,8 +469,7 @@ func TestHandler(t *testing.T) {
 			_, err := rand.Read(contents[i])
 			require.NoError(t, err)
 			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			// ensure CreatedAt of caches are different, in upload order
+			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-			backdateCache(t, handler, keys[i], time.Duration(len(contents)-i)*time.Second)
 		}
 
 		reqKeys := strings.Join([]string{
@@ -548,8 +554,7 @@ func TestHandler(t *testing.T) {
 			_, err := rand.Read(contents[i])
 			require.NoError(t, err)
 			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			// ensure CreatedAt of caches are different, in upload order
+			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-			backdateCache(t, handler, keys[i], time.Duration(len(contents)-i)*time.Second)
 		}
 
 		reqKeys := strings.Join([]string{
@@ -602,8 +607,7 @@ func TestHandler(t *testing.T) {
 			_, err := rand.Read(contents[i])
 			require.NoError(t, err)
 			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			// ensure CreatedAt of caches are different, in upload order
+			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-			backdateCache(t, handler, keys[i], time.Duration(len(contents)-i)*time.Second)
 		}
 
 		reqKeys := strings.Join([]string{
@@ -642,20 +646,6 @@ func TestHandler(t *testing.T) {
 	})
 }
 
-// backdateCache rewrites a cache's CreatedAt. It has one-second resolution, so age-ordering
-// tests set it directly instead of sleeping a second between uploads.
-func backdateCache(t *testing.T, handler *Handler, key string, age time.Duration) {
-	db, err := handler.openDB()
-	require.NoError(t, err)
-	defer db.Close()
-
-	var caches []*Cache
-	require.NoError(t, db.Find(&caches, bolthold.Where("Key").Eq(key)))
-	require.Len(t, caches, 1)
-	caches[0].CreatedAt = time.Now().Add(-age).Unix()
-	require.NoError(t, db.Update(caches[0].ID, caches[0]))
-}
-
 func uploadCacheNormally(t *testing.T, base, key, version string, content []byte) { //nolint:unparam // pre-existing issue from nektos/act
 	var id uint64
 	{

act/common/executor_max_parallel_test.go

@@ -0,0 +1,89 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package common
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Simple fast test that verifies max-parallel: 2 limits concurrency
+func TestMaxParallel2Quick(t *testing.T) {
+	ctx := context.Background()
+
+	var currentRunning atomic.Int32
+	var maxSimultaneous atomic.Int32
+
+	executors := make([]Executor, 4)
+	for i := range 4 {
+		executors[i] = func(ctx context.Context) error {
+			current := currentRunning.Add(1)
+
+			// Update max if needed
+			for {
+				maxValue := maxSimultaneous.Load()
+				if current <= maxValue || maxSimultaneous.CompareAndSwap(maxValue, current) {
+					break
+				}
+			}
+
+			time.Sleep(10 * time.Millisecond)
+			currentRunning.Add(-1)
+			return nil
+		}
+	}
+
+	err := NewParallelExecutor(2, executors...)(ctx)
+
+	assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+	assert.LessOrEqual(t, maxSimultaneous.Load(), int32(2),
+		"Should not exceed max-parallel: 2")
+}
+
+// Test that verifies max-parallel: 1 enforces sequential execution
+func TestMaxParallel1Sequential(t *testing.T) {
+	ctx := context.Background()
+
+	var currentRunning atomic.Int32
+	var maxSimultaneous atomic.Int32
+	var executionOrder []int
+	var orderMutex sync.Mutex
+
+	executors := make([]Executor, 5)
+	for i := range 5 {
+		taskID := i
+		executors[i] = func(ctx context.Context) error {
+			current := currentRunning.Add(1)
+
+			// Track execution order
+			orderMutex.Lock()
+			executionOrder = append(executionOrder, taskID)
+			orderMutex.Unlock()
+
+			// Update max if needed
+			for {
+				maxValue := maxSimultaneous.Load()
+				if current <= maxValue || maxSimultaneous.CompareAndSwap(maxValue, current) {
+					break
+				}
+			}
+
+			time.Sleep(20 * time.Millisecond)
+			currentRunning.Add(-1)
+			return nil
+		}
+	}
+
+	err := NewParallelExecutor(1, executors...)(ctx)
+
+	assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+	assert.Equal(t, int32(1), maxSimultaneous.Load(),
+		"max-parallel: 1 should only run 1 task at a time")
+	assert.Len(t, executionOrder, 5, "All 5 tasks should have executed")
+}

act/common/executor_parallel_advanced_test.go

@@ -0,0 +1,221 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package common
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestMaxParallelJobExecution tests actual job execution with max-parallel
+func TestMaxParallelJobExecution(t *testing.T) {
+	t.Run("MaxParallel=1 Sequential", func(t *testing.T) {
+		var currentRunning atomic.Int32
+		var maxConcurrent int32
+		var executionOrder []int
+		var mu sync.Mutex
+
+		executors := make([]Executor, 5)
+		for i := range 5 {
+			taskID := i
+			executors[i] = func(ctx context.Context) error {
+				current := currentRunning.Add(1)
+
+				// Track max concurrent
+				for {
+					maxValue := atomic.LoadInt32(&maxConcurrent)
+					if current <= maxValue || atomic.CompareAndSwapInt32(&maxConcurrent, maxValue, current) {
+						break
+					}
+				}
+
+				mu.Lock()
+				executionOrder = append(executionOrder, taskID)
+				mu.Unlock()
+
+				time.Sleep(10 * time.Millisecond)
+				currentRunning.Add(-1)
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		err := NewParallelExecutor(1, executors...)(ctx)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		assert.Equal(t, int32(1), maxConcurrent, "Should never exceed 1 concurrent execution")
+		assert.Len(t, executionOrder, 5, "All tasks should execute")
+	})
+
+	t.Run("MaxParallel=3 Limited", func(t *testing.T) {
+		var currentRunning atomic.Int32
+		var maxConcurrent int32
+
+		executors := make([]Executor, 10)
+		for i := range 10 {
+			executors[i] = func(ctx context.Context) error {
+				current := currentRunning.Add(1)
+
+				for {
+					maxValue := atomic.LoadInt32(&maxConcurrent)
+					if current <= maxValue || atomic.CompareAndSwapInt32(&maxConcurrent, maxValue, current) {
+						break
+					}
+				}
+
+				time.Sleep(20 * time.Millisecond)
+				currentRunning.Add(-1)
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		err := NewParallelExecutor(3, executors...)(ctx)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		assert.LessOrEqual(t, int(maxConcurrent), 3, "Should never exceed 3 concurrent executions")
+		assert.GreaterOrEqual(t, int(maxConcurrent), 1, "Should have at least 1 concurrent execution")
+	})
+
+	t.Run("MaxParallel=0 Uses1Worker", func(t *testing.T) {
+		var maxConcurrent int32
+		var currentRunning atomic.Int32
+
+		executors := make([]Executor, 5)
+		for i := range 5 {
+			executors[i] = func(ctx context.Context) error {
+				current := currentRunning.Add(1)
+
+				for {
+					maxValue := atomic.LoadInt32(&maxConcurrent)
+					if current <= maxValue || atomic.CompareAndSwapInt32(&maxConcurrent, maxValue, current) {
+						break
+					}
+				}
+
+				time.Sleep(10 * time.Millisecond)
+				currentRunning.Add(-1)
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		// When maxParallel is 0 or negative, it defaults to 1
+		err := NewParallelExecutor(0, executors...)(ctx)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		assert.Equal(t, int32(1), maxConcurrent, "Should use 1 worker when max-parallel is 0")
+	})
+}
+
+// TestMaxParallelWithErrors tests error handling with max-parallel
+func TestMaxParallelWithErrors(t *testing.T) {
+	t.Run("OneTaskFailsOthersContinue", func(t *testing.T) {
+		var successCount int32
+
+		executors := make([]Executor, 5)
+		for i := range 5 {
+			taskID := i
+			executors[i] = func(ctx context.Context) error {
+				if taskID == 2 {
+					return assert.AnError
+				}
+				atomic.AddInt32(&successCount, 1)
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		err := NewParallelExecutor(2, executors...)(ctx)
+
+		// Should return the error from task 2
+		assert.Error(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		// Other tasks should still execute
+		assert.Equal(t, int32(4), successCount, "4 tasks should succeed")
+	})
+
+	t.Run("ContextCancellation", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+
+		var startedCount int32
+		executors := make([]Executor, 10)
+		for i := range 10 {
+			executors[i] = func(ctx context.Context) error {
+				atomic.AddInt32(&startedCount, 1)
+				time.Sleep(100 * time.Millisecond)
+				return nil
+			}
+		}
+
+		// Cancel after a short delay
+		go func() {
+			time.Sleep(30 * time.Millisecond)
+			cancel()
+		}()
+
+		err := NewParallelExecutor(3, executors...)(ctx)
+		assert.Error(t, err)                     //nolint:testifylint // pre-existing issue from nektos/act
+		assert.ErrorIs(t, err, context.Canceled) //nolint:testifylint // pre-existing issue from nektos/act
+
+		// Not all tasks should start due to cancellation (but timing may vary)
+		// Just verify cancellation occurred
+		t.Logf("Started %d tasks before cancellation", startedCount)
+	})
+}
+
+// TestMaxParallelResourceSharing tests resource sharing scenarios
+func TestMaxParallelResourceSharing(t *testing.T) {
+	t.Run("SharedResourceWithMutex", func(t *testing.T) {
+		var sharedCounter int
+		var mu sync.Mutex
+
+		executors := make([]Executor, 100)
+		for i := range 100 {
+			executors[i] = func(ctx context.Context) error {
+				mu.Lock()
+				sharedCounter++
+				mu.Unlock()
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		err := NewParallelExecutor(10, executors...)(ctx)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		assert.Equal(t, 100, sharedCounter, "All tasks should increment counter")
+	})
+
+	t.Run("ChannelCommunication", func(t *testing.T) {
+		resultChan := make(chan int, 50)
+
+		executors := make([]Executor, 50)
+		for i := range 50 {
+			taskID := i
+			executors[i] = func(ctx context.Context) error {
+				resultChan <- taskID
+				return nil
+			}
+		}
+
+		ctx := context.Background()
+		err := NewParallelExecutor(5, executors...)(ctx)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+
+		close(resultChan)
+
+		results := make(map[int]bool)
+		for result := range resultChan {
+			results[result] = true
+		}
+
+		assert.Len(t, results, 50, "All task IDs should be received")
+	})
+}

act/common/executor_test.go

@@ -9,9 +9,9 @@ import (
 	"errors"
 	"reflect"
 	"strings"
-	"sync"
 	"sync/atomic"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -82,45 +82,44 @@ func TestNewConditionalExecutor(t *testing.T) {
 	assert.Equal(1, falseCount)
 }
 
-// concurrencyProbe returns an executor recording the peak number of concurrent copies. Copies
+func TestNewParallelExecutor(t *testing.T) {
-// block until wantActive are in flight so the peak is exact without sleeping, and later copies
+	assert := assert.New(t)
-// find the gate already open so the last one still finishes with no partner left.
-func concurrencyProbe(wantActive int32) (exec Executor, count, maxActive *atomic.Int32) {
-	var counted, active, peak atomic.Int32
-	var once sync.Once
-	reached := make(chan struct{})
 
-	return func(ctx context.Context) error {
+	ctx := context.Background()
-		counted.Add(1)
+
-		running := active.Add(1)
+	var count, activeCount, maxCount atomic.Int32
+	emptyWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
+		count.Add(1)
+
+		active := activeCount.Add(1)
 		for {
-			seen := peak.Load()
+			m := maxCount.Load()
-			if running <= seen || peak.CompareAndSwap(seen, running) {
+			if active <= m || maxCount.CompareAndSwap(m, active) {
 				break
 			}
 		}
-		if running >= wantActive {
+		time.Sleep(2 * time.Second)
-			once.Do(func() { close(reached) })
+		activeCount.Add(-1)
-		}
+
-		<-reached
-		active.Add(-1)
 		return nil
-	}, &counted, &peak
+	})
-}
 
-func TestNewParallelExecutor(t *testing.T) {
+	err := NewParallelExecutor(2, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
-	ctx := context.Background()
 
-	exec, count, maxActive := concurrencyProbe(2)
+	assert.Equal(int32(3), count.Load(), "should run all 3 executors")
-	require.NoError(t, NewParallelExecutor(2, exec, exec, exec)(ctx))
+	assert.Equal(int32(2), maxCount.Load(), "should run at most 2 executors in parallel")
-	assert.Equal(t, int32(3), count.Load(), "should run all 3 executors")
+	assert.NoError(err) //nolint:testifylint // pre-existing issue from nektos/act
-	assert.Equal(t, int32(2), maxActive.Load(), "should run at most 2 executors in parallel")
 
-	// parallelism below 1 falls back to a single worker
+	// Reset to test running the executor with 0 parallelism
-	exec, count, maxActive = concurrencyProbe(1)
+	count.Store(0)
-	require.NoError(t, NewParallelExecutor(0, exec, exec, exec)(ctx))
+	activeCount.Store(0)
-	assert.Equal(t, int32(3), count.Load(), "should run all 3 executors")
+	maxCount.Store(0)
-	assert.Equal(t, int32(1), maxActive.Load(), "should run at most 1 executor in parallel")
+
+	errSingle := NewParallelExecutor(0, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
+
+	assert.Equal(int32(3), count.Load(), "should run all 3 executors")
+	assert.Equal(int32(1), maxCount.Load(), "should run at most 1 executors in parallel")
+	assert.NoError(errSingle)
 }
 
 func TestNewParallelExecutorEmpty(t *testing.T) {
@@ -174,23 +173,6 @@ func TestNewParallelExecutorCanceled(t *testing.T) {
 	assert.Error(errExpected, err) //nolint:testifylint // pre-existing issue from nektos/act
 }
 
-func TestNewParallelExecutorRunsRemainingAfterFailure(t *testing.T) {
-	var successCount atomic.Int32
-	executors := make([]Executor, 5)
-	for i := range executors {
-		executors[i] = func(ctx context.Context) error {
-			if i == 2 {
-				return errors.New("fake error")
-			}
-			successCount.Add(1)
-			return nil
-		}
-	}
-
-	require.Error(t, NewParallelExecutor(2, executors...)(context.Background()))
-	assert.Equal(t, int32(4), successCount.Load(), "a failing executor must not stop the others")
-}
-
 func TestExecutorConditionalsAndFinally(t *testing.T) {
 	ctx := context.Background()
 	var calls []string

act/common/git/git.go

@@ -16,7 +16,6 @@ import (
 	"sync"
 
 	"gitea.com/gitea/runner/act/common"
-	"gitea.com/gitea/runner/internal/pkg/lock"
 
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/config"
@@ -33,7 +32,7 @@ var (
 	githubHTTPRegex     = regexp.MustCompile(`^https?://.*github.com.*/(.+)/(.+?)(?:.git)?$`)
 	githubSSHRegex      = regexp.MustCompile(`github.com[:/](.+)/(.+?)(?:.git)?$`)
 
-	cloneLocks lock.Keyed[string] // key: clone target directory
+	cloneLocks sync.Map // key: clone target directory; value: *sync.Mutex
 
 	ErrShortRef = errors.New("short SHA references are not supported")
 	ErrNoRepo   = errors.New("unable to find git repo")
@@ -44,7 +43,10 @@ var (
 // Callers reading files inside dir (e.g. tarring a checked-out action into a job container) must hold this lock too,
 // otherwise a concurrent NewGitCloneExecutor on the same dir can mutate the worktree mid-read.
 func AcquireCloneLock(dir string) func() {
-	return cloneLocks.Lock(dir)
+	v, _ := cloneLocks.LoadOrStore(dir, &sync.Mutex{})
+	mu := v.(*sync.Mutex)
+	mu.Lock()
+	return mu.Unlock
 }
 
 type Error struct {
@@ -259,10 +261,6 @@ type NewGitCloneExecutorInput struct {
 	// 0 for full clone.
 	Depth int
 
-	// Quiet drops the informational clone line to debug level, for callers that log their own
-	// download summary (the setup section's action report).
-	Quiet bool
-
 	// For Gitea
 	InsecureSkipTLS bool
 }
@@ -349,11 +347,7 @@ func gitOptions(token string) (fetchOptions git.FetchOptions, pullOptions git.Pu
 func NewGitCloneExecutor(input NewGitCloneExecutorInput) common.Executor {
 	return func(ctx context.Context) error {
 		logger := common.Logger(ctx)
-		if input.Quiet {
+		logger.Infof("git clone '%s' # ref=%s", input.URL, input.Ref)
-			logger.Debugf("git clone '%s' # ref=%s", input.URL, input.Ref)
-		} else {
-			logger.Infof("git clone '%s' # ref=%s", input.URL, input.Ref)
-		}
 		logger.Debugf("  cloning %s to %s", input.URL, input.Dir)
 
 		defer AcquireCloneLock(input.Dir)()

act/common/git/git_test.go

@@ -12,14 +12,11 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 	"syscall"
 	"testing"
 	"time"
 
-	"gitea.com/gitea/runner/act/common"
-
-	log "github.com/sirupsen/logrus"
-	logrustest "github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -407,44 +404,6 @@ func TestGitCloneExecutorOfflineMode(t *testing.T) {
 	})
 }
 
-func TestGitCloneExecutorQuietDemotesCloneLine(t *testing.T) {
-	remoteDir := t.TempDir()
-	require.NoError(t, gitCmd("init", "--bare", "--initial-branch=main", remoteDir))
-	workDir := t.TempDir()
-	require.NoError(t, gitCmd("clone", remoteDir, workDir))
-	require.NoError(t, gitCmd("-C", workDir, "checkout", "-b", "main"))
-	require.NoError(t, gitCmd("-C", workDir, "commit", "--allow-empty", "-m", "initial"))
-	require.NoError(t, gitCmd("-C", workDir, "push", "-u", "origin", "main"))
-
-	// Quiet callers report the download themselves, so the clone line must not reach the job log.
-	for name, quiet := range map[string]bool{"quiet": true, "not quiet": false} {
-		t.Run(name, func(t *testing.T) {
-			logger, hook := logrustest.NewNullLogger()
-			logger.SetLevel(log.InfoLevel)
-			ctx := common.WithLogger(context.Background(), logger.WithField("job", "j1"))
-
-			require.NoError(t, NewGitCloneExecutor(NewGitCloneExecutorInput{
-				URL:   remoteDir,
-				Ref:   "main",
-				Dir:   t.TempDir(),
-				Quiet: quiet,
-			})(ctx))
-
-			var cloneLines int
-			for _, entry := range hook.AllEntries() {
-				if strings.HasPrefix(entry.Message, "git clone ") {
-					cloneLines++
-				}
-			}
-			if quiet {
-				assert.Zero(t, cloneLines)
-			} else {
-				assert.Equal(t, 1, cloneLines)
-			}
-		})
-	}
-}
-
 func TestGitCloneExecutorShallow(t *testing.T) {
 	// Build a local "remote" with several commits on main plus a tag, so a full clone would pull noticeably more history than a shallow one.
 	remoteDir := t.TempDir()
@@ -609,4 +568,12 @@ func TestAcquireCloneLock(t *testing.T) {
 			t.Fatal("acquire on a different directory must not block")
 		}
 	})
+
+	t.Run("same directory reuses the same mutex", func(t *testing.T) {
+		dir := t.TempDir()
+
+		v1, _ := cloneLocks.LoadOrStore(dir, &sync.Mutex{})
+		v2, _ := cloneLocks.LoadOrStore(dir, &sync.Mutex{})
+		require.Same(t, v1, v2)
+	})
 }

act/common/outbound_ip.go

@@ -19,9 +19,7 @@ func GetOutboundIP() net.IP {
 	conn, err := net.Dial("udp", "8.8.8.8:80")
 	if err == nil {
 		defer conn.Close()
-		if addr, ok := conn.LocalAddr().(*net.UDPAddr); ok {
+		return conn.LocalAddr().(*net.UDPAddr).IP
-			return addr.IP
-		}
 	}
 
 	// So the machine cannot access the internet. Pick an IP address from network interfaces.

act/container/container_types.go

@@ -82,7 +82,6 @@ type NewDockerBuildExecutorInput struct {
 	BuildContext io.Reader
 	ImageTag     string
 	Platform     string
-	BuildArgs    map[string]*string
 }
 
 // NewDockerNetworkCreateExecutorInput the input for the NewDockerNetworkCreateExecutor function

act/container/docker_build.go

@@ -49,7 +49,6 @@ func NewDockerBuildExecutor(input NewDockerBuildExecutorInput) common.Executor {
 			Remove:      true,
 			AuthConfigs: LoadDockerAuthConfigs(ctx),
 			Dockerfile:  input.Dockerfile,
-			BuildArgs:   input.BuildArgs,
 		}
 		platform, err := parsePlatform(input.Platform)
 		if err != nil {

act/container/docker_create_flags.go

@@ -1,86 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"slices"
-
-	"github.com/kballard/go-shellquote"
-	"github.com/spf13/pflag"
-)
-
-const (
-	pullPolicyAlways  = "always"
-	pullPolicyMissing = "missing"
-	pullPolicyNever   = "never"
-)
-
-var pullPolicies = []string{pullPolicyAlways, pullPolicyMissing, pullPolicyNever}
-
-// createFlags are the flags docker/cli registers on the `create` and `run` commands
-// instead of in addFlags, so they are not part of containerOptions.
-type createFlags struct {
-	platform     string
-	pull         string
-	name         string
-	useAPISocket bool
-}
-
-func registerCreateFlags(flags *pflag.FlagSet) *createFlags {
-	cf := new(createFlags)
-	flags.StringVar(&cf.platform, "platform", "", "Set platform if server is multi-platform capable")
-	flags.StringVar(&cf.pull, "pull", pullPolicyMissing, `Pull image before creating ("always", "missing", "never")`)
-	flags.StringVar(&cf.name, "name", "", "Assign a name to the container")
-	flags.BoolVar(&cf.useAPISocket, "use-api-socket", false, "Bind mount Docker API socket and required auth")
-	// Accepted without effect: pull progress is only logged at debug level, and docker
-	// no longer implements content trust.
-	flags.BoolP("quiet", "q", false, "Suppress the pull output")
-	flags.Bool("disable-content-trust", true, "Skip image verification (deprecated)")
-	return cf
-}
-
-// parseContainerOptions parses a container options string. The flags are returned even
-// on error, holding whatever was read before the failure.
-func parseContainerOptions(options string) (*pflag.FlagSet, *containerOptions, *createFlags, error) {
-	flags := pflag.NewFlagSet("container_flags", pflag.ContinueOnError)
-	flags.SetOutput(io.Discard)
-	copts := addFlags(flags)
-	cf := registerCreateFlags(flags)
-
-	args, err := shellquote.Split(options)
-	if err != nil {
-		return flags, copts, cf, fmt.Errorf("Cannot split container options: '%s': '%w'", options, err)
-	}
-
-	if err := flags.Parse(args); err != nil {
-		return flags, copts, cf, fmt.Errorf("Cannot parse container options: '%s': '%w'", options, err)
-	}
-
-	return flags, copts, cf, nil
-}
-
-// createFlagsFromOptions reads the create-level flags that have to be known before the
-// container is created. Malformed options keep the defaults here and are reported by
-// mergeContainerConfigs at create time.
-func createFlagsFromOptions(options string) *createFlags {
-	_, _, cf, _ := parseContainerOptions(options)
-	return cf
-}
-
-func (cf *createFlags) validate() error {
-	if !slices.Contains(pullPolicies, cf.pull) {
-		return fmt.Errorf("invalid --pull option %q: must be one of %q", cf.pull, pullPolicies)
-	}
-
-	if cf.useAPISocket {
-		return errors.New("--use-api-socket is not supported, use the runner's container.docker_host setting to expose a docker socket")
-	}
-
-	return nil
-}

act/container/docker_create_flags_test.go

@@ -1,62 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package container
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCreateFlagsFromOptions(t *testing.T) {
-	for _, tc := range []struct {
-		options  string
-		platform string
-		pull     string
-	}{
-		{"", "", pullPolicyMissing},
-		{"-v /a:/b --platform=linux/arm64 --pull always", "linux/arm64", pullPolicyAlways},
-		{"--platform linux/arm/v7 --pull never", "linux/arm/v7", pullPolicyNever},
-		{`--platform "linux/amd64`, "", pullPolicyMissing}, // malformed, defaults kept
-	} {
-		t.Run(tc.options, func(t *testing.T) {
-			cf := createFlagsFromOptions(tc.options)
-			assert.Equal(t, tc.platform, cf.platform)
-			assert.Equal(t, tc.pull, cf.pull)
-		})
-	}
-}
-
-func TestCreateFlagsValidate(t *testing.T) {
-	for _, tc := range []struct {
-		options string
-		wantErr string
-	}{
-		{"--quiet --disable-content-trust --name mine", ""},
-		{"--pull sometimes", `invalid --pull option "sometimes"`},
-		{"--use-api-socket", "--use-api-socket is not supported"},
-	} {
-		t.Run(tc.options, func(t *testing.T) {
-			err := createFlagsFromOptions(tc.options).validate()
-			if tc.wantErr == "" {
-				require.NoError(t, err)
-				return
-			}
-			require.ErrorContains(t, err, tc.wantErr)
-		})
-	}
-}
-
-func TestNewContainerAppliesCreateFlags(t *testing.T) {
-	input := &NewContainerInput{Platform: "linux/amd64", Options: "--platform linux/arm64 --pull never"}
-	cr, ok := NewContainer(input).(*containerReference)
-	require.True(t, ok)
-	assert.Equal(t, "linux/arm64", input.Platform)
-	assert.Equal(t, pullPolicyNever, cr.pullPolicy)
-
-	kept := &NewContainerInput{Platform: "linux/amd64", Options: "--privileged"}
-	NewContainer(kept)
-	assert.Equal(t, "linux/amd64", kept.Platform)
-}

act/container/docker_pull.go

@@ -72,9 +72,7 @@ func NewDockerPullExecutor(input NewDockerPullExecutorInput) common.Executor {
 
 				_ = logDockerResponse(logger, reader, err != nil)
 			}
-			if err != nil {
+			return err
-				return fmt.Errorf("failed to pull image '%s' (%s): %w", imageRef, input.Platform, err)
-			}
 		}
 		return nil
 	}

act/container/docker_run.go

@@ -35,6 +35,7 @@ import (
 	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
 	"github.com/gobwas/glob"
 	"github.com/joho/godotenv"
+	"github.com/kballard/go-shellquote"
 	"github.com/moby/moby/api/pkg/stdcopy"
 	"github.com/moby/moby/api/types/container"
 	"github.com/moby/moby/api/types/mount"
@@ -42,6 +43,7 @@ import (
 	"github.com/moby/moby/api/types/system"
 	"github.com/moby/moby/client"
 	specs "github.com/opencontainers/image-spec/specs-go/v1"
+	"github.com/spf13/pflag"
 )
 
 // drainGracePeriod bounds how long we wait for an output-copy goroutine to
@@ -55,12 +57,6 @@ const drainGracePeriod = 2 * time.Second
 func NewContainer(input *NewContainerInput) ExecutionsEnvironment {
 	cr := new(containerReference)
 	cr.input = input
-	// Resolved up front because the image pull runs before the container is created.
-	cf := createFlagsFromOptions(input.Options)
-	if cf.platform != "" {
-		cr.input.Platform = cf.platform
-	}
-	cr.pullPolicy = cf.pull
 	return cr
 }
 
@@ -141,11 +137,6 @@ func (cr *containerReference) Start(attach bool) common.Executor {
 }
 
 func (cr *containerReference) Pull(forcePull bool) common.Executor {
-	if cr.pullPolicy == pullPolicyNever {
-		return common.NewInfoExecutor("docker pull skipped image=%s, --pull=never in the options", cr.input.Image)
-	}
-	forcePull = forcePull || cr.pullPolicy == pullPolicyAlways
-
 	return common.
 		NewInfoExecutor("docker pull image=%s platform=%s username=%s forcePull=%t", cr.input.Image, cr.input.Platform, cr.input.Username, forcePull).
 		Then(
@@ -241,12 +232,11 @@ func (cr *containerReference) ReplaceLogWriter(stdout, stderr io.Writer) (io.Wri
 }
 
 type containerReference struct {
-	cli        client.APIClient
+	cli   client.APIClient
-	id         string
+	id    string
-	input      *NewContainerInput
+	input *NewContainerInput
-	pullPolicy string
+	UID   int
-	UID        int
+	GID   int
-	GID        int
 	// attachDone is closed by the attach() streaming goroutine once it has
 	// drained and flushed the container's output. wait() blocks on it so the
 	// tail of the log lands before the step proceeds.
@@ -386,11 +376,6 @@ func (cr *containerReference) find() common.Executor {
 	}
 }
 
-// isContainerGone reports whether a failed remove still left the container gone (NotFound or Conflict).
-func isContainerGone(err error) bool {
-	return cerrdefs.IsNotFound(err) || cerrdefs.IsConflict(err)
-}
-
 func (cr *containerReference) remove() common.Executor {
 	return func(ctx context.Context) error {
 		if cr.id == "" {
@@ -402,7 +387,7 @@ func (cr *containerReference) remove() common.Executor {
 			RemoveVolumes: true,
 			Force:         true,
 		})
-		if err != nil && !isContainerGone(err) {
+		if err != nil {
 			logger.Error(fmt.Errorf("failed to remove container: %w", err))
 		}
 
@@ -421,13 +406,17 @@ func (cr *containerReference) mergeContainerConfigs(ctx context.Context, config
 	}
 
 	// parse configuration from CLI container.options
-	flags, copts, cf, err := parseContainerOptions(input.Options)
+	flags := pflag.NewFlagSet("container_flags", pflag.ContinueOnError)
+	copts := addFlags(flags)
+
+	optionsArgs, err := shellquote.Split(input.Options)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, fmt.Errorf("Cannot split container options: '%s': '%w'", input.Options, err)
 	}
 
-	if err := cf.validate(); err != nil {
+	err = flags.Parse(optionsArgs)
-		return nil, nil, fmt.Errorf("Cannot process container options: '%s': '%w'", input.Options, err)
+	if err != nil {
+		return nil, nil, fmt.Errorf("Cannot parse container options: '%s': '%w'", input.Options, err)
 	}
 
 	// FIXME: If everything is fine after gitea/act v0.260.0, remove the following comment.
@@ -471,7 +460,8 @@ func (cr *containerReference) mergeContainerConfigs(ctx context.Context, config
 
 	logger.Debugf("Custom container.HostConfig from options ==> %+v", containerConfig.HostConfig)
 
-	overlayVolumes(hostConfig, containerConfig.HostConfig)
+	hostConfig.Binds = append(hostConfig.Binds, containerConfig.HostConfig.Binds...)
+	hostConfig.Mounts = append(hostConfig.Mounts, containerConfig.HostConfig.Mounts...)
 	binds := hostConfig.Binds
 	mounts := hostConfig.Mounts
 	networkMode := hostConfig.NetworkMode
@@ -481,9 +471,6 @@ func (cr *containerReference) mergeContainerConfigs(ctx context.Context, config
 	}
 	hostConfig.Binds = binds
 	hostConfig.Mounts = mounts
-	if cf.name != "" {
-		logger.Warn("--name in the options will be ignored.")
-	}
 	if len(copts.netMode.Value()) > 0 {
 		logger.Warn("--network and --net in the options will be ignored.")
 	}
@@ -1107,34 +1094,6 @@ func (cr *containerReference) sanitizeConfig(ctx context.Context, config *contai
 	return config, hostConfig
 }
 
-// bindTarget returns the container path a bind mounts onto, empty if it cannot be parsed.
-func bindTarget(bind string) string {
-	parsed, err := loader.ParseVolume(bind)
-	if err != nil {
-		return ""
-	}
-	return parsed.Target
-}
-
-// overlayVolumes appends src's volumes to dst, dropping the dst ones they mount over. Docker
-// rejects two mounts on one target, so the volumes declared last have to win.
-func overlayVolumes(dst, src *container.HostConfig) {
-	claimed := map[string]bool{}
-	for _, bind := range src.Binds {
-		if target := bindTarget(bind); target != "" {
-			claimed[target] = true
-		}
-	}
-	for _, mt := range src.Mounts {
-		claimed[mt.Target] = true
-	}
-
-	dst.Binds = append(slices.DeleteFunc(slices.Clone(dst.Binds),
-		func(bind string) bool { return claimed[bindTarget(bind)] }), src.Binds...)
-	dst.Mounts = append(slices.DeleteFunc(slices.Clone(dst.Mounts),
-		func(mt mount.Mount) bool { return claimed[mt.Target] }), src.Mounts...)
-}
-
 type validVolumeMatcher struct {
 	allowAll bool
 	named    []glob.Glob

act/container/docker_run_test.go

@@ -23,7 +23,6 @@ import (
 	cerrdefs "github.com/containerd/errdefs"
 	"github.com/moby/moby/api/pkg/stdcopy"
 	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/api/types/mount"
 	mobyclient "github.com/moby/moby/client"
 	"github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
@@ -117,11 +116,6 @@ func (m *mockDockerClient) ContainerList(ctx context.Context, opts mobyclient.Co
 	return args.Get(0).(mobyclient.ContainerListResult), args.Error(1)
 }
 
-func (m *mockDockerClient) ContainerRemove(ctx context.Context, id string, opts mobyclient.ContainerRemoveOptions) (mobyclient.ContainerRemoveResult, error) {
-	args := m.Called(ctx, id, opts)
-	return args.Get(0).(mobyclient.ContainerRemoveResult), args.Error(1)
-}
-
 type endlessReader struct {
 	io.Reader
 }
@@ -387,40 +381,6 @@ func TestDockerCopyTarStreamErrorInMkdir(t *testing.T) {
 	client.AssertExpectations(t)
 }
 
-// A remove that raced the daemon's AutoRemove teardown is not a failure and must not
-// be logged as one.
-func TestRemoveIgnoresAutoRemoveRace(t *testing.T) {
-	removeOpts := mobyclient.ContainerRemoveOptions{RemoveVolumes: true, Force: true}
-	for _, tc := range []struct {
-		name     string
-		err      error
-		wantLogs bool
-	}{
-		{name: "removal in progress", err: cerrdefs.ErrConflict.WithMessage("removal of container abc is already in progress")},
-		{name: "already removed", err: cerrdefs.ErrNotFound.WithMessage("No such container: abc")},
-		{name: "removed cleanly", err: nil},
-		{name: "real failure", err: errors.New("driver failed to remove root filesystem"), wantLogs: true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			logger, hook := test.NewNullLogger()
-			ctx := common.WithLogger(context.Background(), logger)
-			client := &mockDockerClient{}
-			client.On("ContainerRemove", ctx, "abc", removeOpts).Return(mobyclient.ContainerRemoveResult{}, tc.err)
-			cr := &containerReference{id: "abc", cli: client}
-
-			require.NoError(t, cr.remove()(ctx))
-			assert.Empty(t, cr.id)
-
-			if tc.wantLogs {
-				assert.Len(t, hook.AllEntries(), 1)
-			} else {
-				assert.Empty(t, hook.AllEntries())
-			}
-			client.AssertExpectations(t)
-		})
-	}
-}
-
 // find() must drop a stale cached id so later Copy/Exec don't hit the
 // daemon with a torn-down container.
 func TestFindRevalidatesStaleID(t *testing.T) {
@@ -661,22 +621,3 @@ func TestCheckVolumesRejectsEscapingHostPaths(t *testing.T) {
 	})
 	assert.Empty(t, hostConf.Binds)
 }
-
-func TestMergeContainerConfigsVolumesReplaceRunnerMounts(t *testing.T) {
-	logger, _ := test.NewNullLogger()
-	ctx := common.WithLogger(context.Background(), logger)
-	cr := &containerReference{
-		input: &NewContainerInput{
-			NetworkMode: "bridge",
-			Options:     "--volume /host/tools:/opt/hostedtoolcache",
-		},
-	}
-
-	_, hostConf, err := cr.mergeContainerConfigs(ctx, &container.Config{}, &container.HostConfig{
-		Binds:  []string{"/var/run/docker.sock:/var/run/docker.sock"},
-		Mounts: []mount.Mount{{Type: mount.TypeVolume, Source: "act-toolcache", Target: "/opt/hostedtoolcache"}},
-	})
-	require.NoError(t, err)
-	assert.Equal(t, []string{"/var/run/docker.sock:/var/run/docker.sock", "/host/tools:/opt/hostedtoolcache"}, hostConf.Binds)
-	assert.Empty(t, hostConf.Mounts)
-}

act/container/host_environment.go

@@ -17,7 +17,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"sync"
 	"sync/atomic"
 	"time"
 
@@ -44,25 +43,6 @@ type HostEnvironment struct {
 	CleanUp      func()
 	StdOut       io.Writer
 	AllocatePTY  bool // allocate a pseudo-TTY for each step's process
-
-	// procGroup owns every process the job's steps start. Atomic: Remove may read
-	// it while a step is still starting.
-	procGroupOnce sync.Once
-	procGroup     atomic.Pointer[process.Group]
-}
-
-// processGroup returns the job-scoped process group, creating it on first use.
-// Returns nil if the job object could not be created; Group is nil-safe.
-func (e *HostEnvironment) processGroup(ctx context.Context) *process.Group {
-	e.procGroupOnce.Do(func() {
-		group, err := process.NewGroup()
-		if err != nil {
-			common.Logger(ctx).Warnf("could not create the job's process group; processes a step leaves behind can only be reclaimed by the workspace scan: %v", err)
-			return
-		}
-		e.procGroup.Store(group)
-	})
-	return e.procGroup.Load()
 }
 
 func (e *HostEnvironment) Create(_, _ []string) common.Executor {
@@ -330,10 +310,6 @@ func (e *HostEnvironment) exec(ctx context.Context, command []string, cmdline st
 	} else {
 		wd = e.Path
 	}
-	// Flush any buffered, not-yet-newline-terminated trailing line, as the docker backend
-	// does in waitForCommand, so the final line of a command's output is not lost.
-	defer common.FlushWriter(e.StdOut)
-
 	f, err := lookupPathHost(command[0], env, e.StdOut)
 	if err != nil {
 		return err
@@ -348,8 +324,11 @@ func (e *HostEnvironment) exec(ctx context.Context, command []string, cmdline st
 	cmd.Dir = wd
 	cmd.SysProcAttr = process.SysProcAttr(cmdline, false)
 
-	// Kills the step's whole tree on cancellation and bounds the post-exit I/O
+	// Kill the step's whole process tree on cancellation (a step often launches a
-	// wait, so an orphan holding cmd's stdout pipe cannot hang cmd.Wait().
+	// shell that spawns further background or GUI children) and bound the post-exit
+	// I/O wait, so an orphan inheriting cmd's stdout/stderr pipe can never hang
+	// cmd.Wait() and the runner. See process.TreeKill. The PTY path below may
+	// override SysProcAttr, but never touches Cancel/WaitDelay.
 	treeKill := process.NewTreeKill(cmd)
 
 	var ppty *os.File
@@ -381,11 +360,6 @@ func (e *HostEnvironment) exec(ctx context.Context, command []string, cmdline st
 	if err := cmd.Start(); err != nil {
 		return err
 	}
-	// Assign before the step's Killer so the step's job nests inside the group's;
-	// cancellation still scopes to this step's tree.
-	if err := e.processGroup(ctx).Assign(cmd.Process); err != nil {
-		common.Logger(ctx).Warnf("could not assign the step's process to the job's process group; a process it leaves behind may outlive the job: %v", err)
-	}
 	if k, kerr := treeKill.Capture(cmd.Process); kerr != nil {
 		common.Logger(ctx).Warnf("process tree kill setup failed, falling back to single-process kill: %v", kerr)
 	} else {
@@ -433,12 +407,13 @@ func (e *HostEnvironment) UpdateFromEnv(srcPath string, env *map[string]string)
 	return parseEnvFile(e, srcPath, env)
 }
 
-// removeAll is a var so tests can substitute a blocking stub.
+// removeAll is the filesystem delete used by removeAllWithContext. A package
+// var so tests can substitute a blocking stub without patching os.RemoveAll.
 var removeAll = os.RemoveAll
 
-// removeAllWithContext returns once the delete finishes or ctx is cancelled. On
+// removeAllWithContext runs removeAll in a goroutine and returns once it
-// cancellation the goroutine leaks: a delete inside a syscall cannot be
+// finishes or ctx is cancelled. On cancellation the goroutine is left running —
-// interrupted (see runWithTimeout).
+// a delete blocked inside a syscall cannot be interrupted (see runWithTimeout).
 func removeAllWithContext(ctx context.Context, path string) error {
 	done := make(chan error, 1)
 	go func() { done <- removeAll(path) }()
@@ -480,12 +455,17 @@ func removePathWithRetry(ctx context.Context, path string) error {
 	return lastErr
 }
 
-// buildWindowsWorkspaceKillScript builds a PowerShell command that taskkills
+// buildWindowsWorkspaceKillScript builds a PowerShell command that `taskkill
-// every process tree whose ExecutablePath or CommandLine references one of the
+// /T /F`s every process tree whose ExecutablePath or CommandLine references one
-// given workspace dirs, releasing file handles for cleanup. Win32_Process
+// of the given absolute workspace dirs, releasing file handles for cleanup.
-// exposes both fields (Get-Process doesn't, wmic is deprecated); matching is on
+//
-// the dir+separator prefix via ordinal String methods, so a name-prefix sibling
+// Win32_Process is used because it exposes both ExecutablePath and CommandLine
-// (job1 vs job10) is spared and path metacharacters stay literal.
+// (Get-Process doesn't, wmic is deprecated). Both match the dir+separator
+// prefix, so a sibling dir sharing a name prefix (job1 vs job10) is spared.
+// Ordinal String methods, not -like, so path metacharacters ([ ] ? *) stay
+// literal.
+//
+// Pure function so the quote-escaping can be unit-tested without PowerShell.
 func buildWindowsWorkspaceKillScript(dirs []string) string {
 	quoted := make([]string, len(dirs))
 	for i, d := range dirs {
@@ -521,8 +501,9 @@ func (e *HostEnvironment) terminateRunningProcesses(ctx context.Context) {
 
 	logger := common.Logger(ctx)
 
-	// Dirs we own; a process referencing one is a leftover. ToolCache is shared
+	// Workspace dirs we own. Any process running from or referencing one is a
-	// across jobs, and Workdir may be a caller-owned checkout.
+	// leftover job process. ToolCache is shared across jobs; Workdir only when
+	// we own it (else it's a caller-provided checkout, e.g. act local mode).
 	owned := []string{e.Path, e.TmpDir}
 	if e.CleanWorkdir {
 		owned = append(owned, e.Workdir)
@@ -549,24 +530,21 @@ func (e *HostEnvironment) terminateRunningProcesses(ctx context.Context) {
 	if err != nil {
 		logger.Debugf("workspace process-tree kill via PowerShell failed: %v output=%s", err, strings.TrimSpace(string(out)))
 	}
-
-	// Win32_Process exposes no working directory, so the scan above misses a
-	// process that merely runs in a workspace dir while pinning a handle on it.
-	if killed, err := process.KillProcessesWithCWDUnder(killCtx, dirs); err != nil {
-		logger.Debugf("workspace process kill by working directory reported errors: %v", err)
-	} else if killed > 0 {
-		logger.Debugf("terminated %d leftover process(es) by workspace working directory", killed)
-	}
 }
 
-// hostCleanupTimeout bounds each teardown phase so one stalled delete cannot
+// hostCleanupTimeout bounds each filesystem-teardown phase of the host
-// wedge the runner slot. A var so tests can shrink it.
+// environment so a single stalled delete cannot wedge the runner slot forever.
+// A var (not const) so tests can shrink it.
 var hostCleanupTimeout = 30 * time.Second
 
-// runWithTimeout returns context.DeadlineExceeded once timeout elapses, leaking
+// runWithTimeout runs fn in a goroutine and returns once it finishes or timeout
-// the goroutine: a delete blocked in a syscall (AV filter driver, dead network
+// elapses, whichever comes first. On timeout the goroutine is left running — an
-// mount) cannot be interrupted, and leaking scratch state beats losing the
+// os.RemoveAll blocked inside a delete syscall (AV/EDR filter drivers, an
-// runner's capacity slot forever. The idle stale-dir sweep reclaims it later.
+// unresponsive network mount, a dying disk) cannot be interrupted — and
+// context.DeadlineExceeded is returned. Leaking the goroutine and the scratch
+// state it was deleting is strictly better than blocking the caller forever and
+// permanently losing the runner's capacity slot; the leaked scratch dir is
+// reclaimed later by the runner's idle stale-dir sweep.
 func runWithTimeout(fn func(), timeout time.Duration) error {
 	done := make(chan struct{})
 	go func() {
@@ -587,15 +565,14 @@ func (e *HostEnvironment) Remove() common.Executor {
 	return func(ctx context.Context) error {
 		logger := common.Logger(ctx)
 
-		// End lingering processes before removing the workspace; on Windows their
+		// Ensure any lingering child processes are ended before attempting
-		// file locks block cleanup. Closing the group is deterministic, the scan a net.
+		// to remove the workspace (Windows file locks otherwise prevent cleanup).
-		if err := e.procGroup.Load().Close(); err != nil {
-			logger.Debugf("closing the job's process group failed: %v", err)
-		}
 		e.terminateRunningProcesses(ctx)
 
-		// Removes per-job misc state only, never the toolcache root. Bounded because
+		// Only removes per-job misc state. Must not remove the cache/toolcache root.
-		// CleanUp is a caller-supplied, typically unbounded os.RemoveAll.
+		// Bound it: CleanUp is a caller-supplied, typically unbounded os.RemoveAll,
+		// and a delete stalled by a filesystem filter driver would otherwise hang
+		// the job forever at "Cleaning up container" and hold the capacity slot.
 		if e.CleanUp != nil {
 			logger.Debugf("running host environment cleanup callback")
 			if err := runWithTimeout(e.CleanUp, hostCleanupTimeout); err != nil {
@@ -626,7 +603,8 @@ func (e *HostEnvironment) Remove() common.Executor {
 				return errors.Join(errs...)
 			}
 		}
-		// Teardown timed out; warned above. Do not fail job completion over it.
+		// Bounded teardown timed out; warnings already logged above. Do not
+		// fail job completion — leaked scratch is reclaimed by the idle sweep.
 		return nil
 	}
 }

act/container/linux_container_environment_extensions.go

@@ -66,15 +66,12 @@ func (*LinuxContainerEnvironmentExtensions) JoinPathVariable(paths ...string) st
 	return strings.Join(paths, ":")
 }
 
-// DefaultToolCache is where the runner mounts the tool cache inside job containers.
-const DefaultToolCache = "/opt/hostedtoolcache"
-
 func (*LinuxContainerEnvironmentExtensions) GetRunnerContext(ctx context.Context) map[string]any {
 	return map[string]any{
 		"os":         "Linux",
 		"arch":       RunnerArch(ctx),
 		"temp":       "/tmp",
-		"tool_cache": DefaultToolCache,
+		"tool_cache": "/opt/hostedtoolcache",
 	}
 }
 

act/container/parse_env_file.go

@@ -13,9 +13,6 @@ import (
 	"strings"
 
 	"gitea.com/gitea/runner/act/common"
-
-	"golang.org/x/text/encoding/unicode"
-	"golang.org/x/text/transform"
 )
 
 func parseEnvFile(e Container, srcPath string, env *map[string]string) common.Executor {
@@ -31,19 +28,11 @@ func parseEnvFile(e Container, srcPath string, env *map[string]string) common.Ex
 		if err != nil && err != io.EOF {
 			return err
 		}
-		// Decode by BOM: Windows PowerShell 5.1 redirection writes UTF-16, and some
+		s := bufio.NewScanner(reader)
-		// tools emit a UTF-8 BOM. Without a BOM the file is read as UTF-8, as before.
-		decoded := transform.NewReader(reader, unicode.BOMOverride(unicode.UTF8.NewDecoder()))
-
-		s := bufio.NewScanner(decoded)
 		// Default 64 KiB max token size is too small for realistic env-file lines; allow up to 16 MiB.
 		s.Buffer(make([]byte, 0, 64*1024), 16*1024*1024)
 		for s.Scan() {
 			line := s.Text()
-			// GitHub's runner ignores blank lines
-			if strings.TrimSpace(line) == "" {
-				continue
-			}
 			singleLineEnv := strings.Index(line, "=")
 			multiLineEnv := strings.Index(line, "<<")
 			if singleLineEnv != -1 && (multiLineEnv == -1 || singleLineEnv < multiLineEnv) {

act/container/parse_env_file_test.go

@@ -13,8 +13,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/text/encoding"
-	"golang.org/x/text/encoding/unicode"
 )
 
 func newTestHostEnv(t *testing.T) (*HostEnvironment, string) {
@@ -66,63 +64,6 @@ func TestParseEnvFileLineExceedsBufferReportsScannerError(t *testing.T) {
 	assert.Contains(t, err.Error(), "reading env file")
 }
 
-// Regression test: a blank line used to fail the job at "Complete Job", after
-// every step had already been recorded as successful.
-func TestParseEnvFileBlankLines(t *testing.T) {
-	e, envPath := newTestHostEnv(t)
-	require.NoError(t, os.WriteFile(envPath, []byte("\nFOO=bar\n\n   \nBAZ=qux\n\n"), 0o600))
-
-	env := map[string]string{}
-	require.NoError(t, parseEnvFile(e, envPath, &env)(context.Background()))
-	assert.Equal(t, "bar", env["FOO"])
-	assert.Equal(t, "qux", env["BAZ"])
-}
-
-// blank lines inside a heredoc value are content, not separators
-func TestParseEnvFileMultiLineKeepsBlankLines(t *testing.T) {
-	e, envPath := newTestHostEnv(t)
-	require.NoError(t, os.WriteFile(envPath, []byte("FOO<<EOF\nline1\n\nline2\nEOF\n"), 0o600))
-
-	env := map[string]string{}
-	require.NoError(t, parseEnvFile(e, envPath, &env)(context.Background()))
-	assert.Equal(t, "line1\n\nline2", env["FOO"])
-}
-
-func TestParseEnvFileUTF8BOM(t *testing.T) {
-	e, envPath := newTestHostEnv(t)
-	content := append([]byte{0xEF, 0xBB, 0xBF}, []byte("FOO=bar\n")...)
-	require.NoError(t, os.WriteFile(envPath, content, 0o600))
-
-	env := map[string]string{}
-	require.NoError(t, parseEnvFile(e, envPath, &env)(context.Background()))
-	assert.Equal(t, "bar", env["FOO"])
-}
-
-// Windows host mode: PowerShell 5.1 redirection writes UTF-16, which used to be
-// unrecognisable as KEY=VALUE, so the writes were silently ignored.
-func TestParseEnvFileUTF16(t *testing.T) {
-	tests := []struct {
-		name    string
-		encoder *encoding.Encoder
-	}{
-		{"little endian", unicode.UTF16(unicode.LittleEndian, unicode.UseBOM).NewEncoder()},
-		{"big endian", unicode.UTF16(unicode.BigEndian, unicode.UseBOM).NewEncoder()},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			e, envPath := newTestHostEnv(t)
-			content, err := tt.encoder.Bytes([]byte("FOO=bar\r\nMULTI<<EOF\r\nline1\r\nEOF\r\n"))
-			require.NoError(t, err)
-			require.NoError(t, os.WriteFile(envPath, content, 0o600))
-
-			env := map[string]string{}
-			require.NoError(t, parseEnvFile(e, envPath, &env)(context.Background()))
-			assert.Equal(t, "bar", env["FOO"])
-			assert.Equal(t, "line1", env["MULTI"])
-		})
-	}
-}
-
 func TestParseEnvFileMissingDelimiter(t *testing.T) {
 	e, envPath := newTestHostEnv(t)
 	require.NoError(t, os.WriteFile(envPath, []byte("FOO<<EOF\nline1\nline2\n"), 0o600))

act/exprparser/functions.go

@@ -274,17 +274,8 @@ func (impl *interperterImpl) jobSuccess() (bool, error) { //nolint:unparam // pr
 	return true, nil
 }
 
-// jobStatus returns the current job status, treating a nil Job context as an
-// empty status so status-check functions never panic on a nil dereference.
-func (impl *interperterImpl) jobStatus() string {
-	if impl.env.Job == nil {
-		return ""
-	}
-	return impl.env.Job.Status
-}
-
 func (impl *interperterImpl) stepSuccess() (bool, error) { //nolint:unparam // pre-existing issue from nektos/act
-	return impl.jobStatus() == "success", nil
+	return impl.env.Job.Status == "success", nil
 }
 
 func (impl *interperterImpl) jobFailure() (bool, error) { //nolint:unparam // pre-existing issue from nektos/act
@@ -301,9 +292,9 @@ func (impl *interperterImpl) jobFailure() (bool, error) { //nolint:unparam // pr
 }
 
 func (impl *interperterImpl) stepFailure() (bool, error) { //nolint:unparam // pre-existing issue from nektos/act
-	return impl.jobStatus() == "failure", nil
+	return impl.env.Job.Status == "failure", nil
 }
 
 func (impl *interperterImpl) cancelled() (bool, error) { //nolint:unparam // pre-existing issue from nektos/act
-	return impl.jobStatus() == "cancelled", nil
+	return impl.env.Job.Status == "cancelled", nil
 }

act/exprparser/functions_test.go

@@ -254,27 +254,3 @@ func TestFunctionFormat(t *testing.T) {
 		})
 	}
 }
-
-func TestStatusFunctionsNilJob(t *testing.T) {
-	// A nil Job context must not panic: the status-check functions should treat
-	// it as an empty status and return false rather than dereferencing nil.
-	env := &EvaluationEnvironment{}
-
-	table := []struct {
-		input   string
-		context string
-		name    string
-	}{
-		{"cancelled()", "job", "cancelled-nil-job"},
-		{"success()", "step", "step-success-nil-job"},
-		{"failure()", "step", "step-failure-nil-job"},
-	}
-
-	for _, tt := range table {
-		t.Run(tt.name, func(t *testing.T) {
-			output, err := NewInterpeter(env, Config{Context: tt.context}).Evaluate(tt.input, DefaultStatusCheckNone)
-			assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
-			assert.Equal(t, false, output)
-		})
-	}
-}

act/exprparser/interpreter_test.go

@@ -11,7 +11,6 @@ import (
 	"gitea.com/gitea/runner/act/model"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestLiterals(t *testing.T) {
@@ -524,9 +523,7 @@ func TestOperatorsBooleanEvaluation(t *testing.T) {
 			assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
 
 			if expected, ok := tt.expected.(float64); ok && math.IsNaN(expected) {
-				number, ok := output.(float64)
+				assert.True(t, math.IsNaN(output.(float64)))
-				require.True(t, ok, "want a number, got %T", output)
-				assert.True(t, math.IsNaN(number))
 			} else {
 				assert.Equal(t, tt.expected, output)
 			}

act/model/action.go

@@ -76,19 +76,17 @@ func (a ActionRunsUsing) IsComposite() bool {
 
 // ActionRuns are a field in Action
 type ActionRuns struct {
-	Using          ActionRunsUsing   `yaml:"using"`
+	Using      ActionRunsUsing   `yaml:"using"`
-	Env            map[string]string `yaml:"env"`
+	Env        map[string]string `yaml:"env"`
-	Main           string            `yaml:"main"`
+	Main       string            `yaml:"main"`
-	Pre            string            `yaml:"pre"`
+	Pre        string            `yaml:"pre"`
-	PreIf          string            `yaml:"pre-if"`
+	PreIf      string            `yaml:"pre-if"`
-	Post           string            `yaml:"post"`
+	Post       string            `yaml:"post"`
-	PostIf         string            `yaml:"post-if"`
+	PostIf     string            `yaml:"post-if"`
-	Image          string            `yaml:"image"`
+	Image      string            `yaml:"image"`
-	PreEntrypoint  string            `yaml:"pre-entrypoint"`
+	Entrypoint string            `yaml:"entrypoint"`
-	Entrypoint     string            `yaml:"entrypoint"`
+	Args       []string          `yaml:"args"`
-	PostEntrypoint string            `yaml:"post-entrypoint"`
+	Steps      []Step            `yaml:"steps"`
-	Args           []string          `yaml:"args"`
-	Steps          []Step            `yaml:"steps"`
 }
 
 // Action describes a metadata file for GitHub actions. The metadata filename must be either action.yml or action.yaml. The data in the metadata file defines the inputs, outputs and main entrypoint for your action.

act/model/action_test.go

@@ -61,22 +61,3 @@ runs:
 		t.Fatalf("error = %q, want invalid value", err)
 	}
 }
-
-func TestReadActionDockerEntrypoints(t *testing.T) {
-	action, err := ReadAction(strings.NewReader(`
-runs:
-  using: docker
-  image: Dockerfile
-  pre-entrypoint: pre.sh
-  post-entrypoint: post.sh
-`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if action.Runs.PreEntrypoint != "pre.sh" {
-		t.Fatalf("pre-entrypoint = %q, want pre.sh", action.Runs.PreEntrypoint)
-	}
-	if action.Runs.PostEntrypoint != "post.sh" {
-		t.Fatalf("post-entrypoint = %q, want post.sh", action.Runs.PostEntrypoint)
-	}
-}

act/model/workflow.go

@@ -86,12 +86,11 @@ func (w *Workflow) OnSchedule() []string {
 	case []any:
 		allSchedules := []string{}
 		for _, v := range val {
-			entry, ok := v.(map[string]any)
+			for k, cron := range v.(map[string]any) {
-			if !ok {
+				if k != "cron" {
-				continue
+					continue
-			}
+				}
-			if cron, ok := entry["cron"].(string); ok {
+				allSchedules = append(allSchedules, cron.(string))
-				allSchedules = append(allSchedules, cron)
 			}
 		}
 		return allSchedules
@@ -444,9 +443,9 @@ func normalizeMatrixValue(key string, val any) ([]any, error) {
 // Scalar values are wrapped into single-element arrays automatically.
 // Template expressions are resolved by EvaluateYamlNode before this method is
 // called; if unresolved, the literal string is wrapped as a one-element fallback.
-func (j *Job) Matrix() (map[string][]any, error) {
+func (j *Job) Matrix() map[string][]any {
 	if j.Strategy == nil || j.Strategy.RawMatrix.Kind != yaml.MappingNode {
-		return map[string][]any{}, nil
+		return nil
 	}
 
 	// Decode to flexible map first so that scalar values don't cause a type error.
@@ -456,9 +455,9 @@ func (j *Job) Matrix() (map[string][]any, error) {
 		// Fall back to the strict array-only format for backward compatibility.
 		var val map[string][]any
 		if !decodeNode(j.Strategy.RawMatrix, &val) {
-			return map[string][]any{}, nil
+			return nil
 		}
-		return val, nil
+		return val
 	}
 
 	// Convert flexible format to expected format with validation
@@ -466,11 +465,12 @@ func (j *Job) Matrix() (map[string][]any, error) {
 	for k, v := range flexVal {
 		normalized, err := normalizeMatrixValue(k, v)
 		if err != nil {
-			return nil, err
+			log.Errorf("matrix validation error: %v", err)
+			return nil
 		}
 		val[k] = normalized
 	}
-	return val, nil
+	return val
 }
 
 // GetMatrixes returns the matrix cross product
@@ -482,38 +482,38 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
 		j.Strategy.FailFast = j.Strategy.GetFailFast()
 		j.Strategy.MaxParallel = j.Strategy.GetMaxParallel()
 
-		m, err := j.Matrix()
+		if m := j.Matrix(); m != nil {
-		if err != nil {
-			return nil, err
-		}
-		if len(m) > 0 {
 			includes := make([]map[string]any, 0)
 			extraIncludes := make([]map[string]any, 0)
-			addInclude := func(raw any) error {
-				include, ok := raw.(map[string]any)
-				if !ok {
-					return fmt.Errorf("the workflow is not valid. Matrix include %v is not a map of matrix keys to values", raw)
-				}
-				for k := range include {
-					if _, ok := m[k]; ok {
-						includes = append(includes, include)
-						return nil
-					}
-				}
-				extraIncludes = append(extraIncludes, include)
-				return nil
-			}
 			for _, v := range m["include"] {
 				switch t := v.(type) {
 				case []any:
 					for _, i := range t {
-						if err := addInclude(i); err != nil {
+						i := i.(map[string]any)
-							return nil, err
+						extraInclude := true
+						for k := range i {
+							if _, ok := m[k]; ok {
+								includes = append(includes, i)
+								extraInclude = false
+								break
+							}
+						}
+						if extraInclude {
+							extraIncludes = append(extraIncludes, i)
 						}
 					}
 				case any:
-					if err := addInclude(t); err != nil {
+					v := v.(map[string]any)
-						return nil, err
+					extraInclude := true
+					for k := range v {
+						if _, ok := m[k]; ok {
+							includes = append(includes, v)
+							extraInclude = false
+							break
+						}
+					}
+					if extraInclude {
+						extraIncludes = append(extraIncludes, v)
 					}
 				}
 			}
@@ -521,13 +521,10 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
 
 			excludes := make([]map[string]any, 0)
 			for _, e := range m["exclude"] {
-				exclude, ok := e.(map[string]any)
+				e := e.(map[string]any)
-				if !ok {
+				for k := range e {
-					return nil, fmt.Errorf("the workflow is not valid. Matrix exclude %v is not a map of matrix keys to values", e)
-				}
-				for k := range exclude {
 					if _, ok := m[k]; ok {
-						excludes = append(excludes, exclude)
+						excludes = append(excludes, e)
 					} else {
 						// We fail completely here because that's what GitHub does for non-existing matrix keys, fail on exclude, silent skip on include
 						return nil, fmt.Errorf("the workflow is not valid. Matrix exclude key %q does not match any key within the matrix", k)

act/model/workflow_test.go

@@ -667,9 +667,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	matrixes, err := job.GetMatrixes()
 	assert.NoError(t, err)                          //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, matrixes, []map[string]any{{}}) //nolint:testifylint // pre-existing issue from nektos/act
-	matrix, err := job.Matrix()
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
-	require.NoError(t, err)
-	assert.Empty(t, matrix)
 	assert.Equal(t, job.Strategy.MaxParallel, 2) //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, job.Strategy.FailFast, true) //nolint:testifylint // pre-existing issue from nektos/act
 
@@ -677,9 +675,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	matrixes, err = job.GetMatrixes()
 	assert.NoError(t, err)                          //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, matrixes, []map[string]any{{}}) //nolint:testifylint // pre-existing issue from nektos/act
-	matrix, err = job.Matrix()
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
-	require.NoError(t, err)
-	assert.Empty(t, matrix)
 	assert.Equal(t, job.Strategy.MaxParallel, 4)  //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, job.Strategy.FailFast, false) //nolint:testifylint // pre-existing issue from nektos/act
 
@@ -687,9 +683,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 	matrixes, err = job.GetMatrixes()
 	assert.NoError(t, err)                          //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, matrixes, []map[string]any{{}}) //nolint:testifylint // pre-existing issue from nektos/act
-	matrix, err = job.Matrix()
+	assert.Equal(t, job.Matrix(), map[string][]any(nil))
-	require.NoError(t, err)
-	assert.Empty(t, matrix)
 	assert.Equal(t, job.Strategy.MaxParallel, 2)  //nolint:testifylint // pre-existing issue from nektos/act
 	assert.Equal(t, job.Strategy.FailFast, false) //nolint:testifylint // pre-existing issue from nektos/act
 
@@ -706,9 +700,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 			{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
 		},
 	)
-	matrix, err = job.Matrix()
+	assert.Equal(t, job.Matrix(), //nolint:testifylint // pre-existing issue from nektos/act
-	require.NoError(t, err)
-	assert.Equal(t, matrix, //nolint:testifylint // pre-existing issue from nektos/act
 		map[string][]any{
 			"datacenter": {"site-c", "site-d"},
 			"exclude": {
@@ -1100,15 +1092,13 @@ jobs:
 				t.Fatal("job not found")
 			}
 
-			matrix, err := job.Matrix()
+			matrix := job.Matrix()
 
 			if tt.wantErr {
-				require.Error(t, err)
 				assert.Nil(t, matrix, "matrix should be nil on error")
 			} else {
-				require.NoError(t, err)
 				if tt.wantLen == 0 {
-					assert.Empty(t, matrix, "no matrix for jobs without strategy")
+					assert.Nil(t, matrix, "matrix should be nil for jobs without strategy")
 				} else {
 					assert.NotNil(t, matrix, "matrix should not be nil")
 					assert.Len(t, matrix, tt.wantLen, "matrix should have expected number of keys")
@@ -1140,9 +1130,11 @@ func TestJobMatrixValidation(t *testing.T) {
 			},
 		}
 
-		matrix, err := job.Matrix()
+		// Attempt to get matrix
-		require.ErrorContains(t, err, `matrix key "config" has invalid nested object value`)
+		matrix := job.Matrix()
-		assert.Nil(t, matrix)
+
+		// Should return nil due to validation error
+		assert.Nil(t, matrix, "matrix with nested map should return nil")
 	})
 }
 

act/runner/action.go

@@ -129,16 +129,6 @@ func readActionImpl(ctx context.Context, step *model.Step, actionDir, actionPath
 	return action, err
 }
 
-// cachedActionTar returns the action's tree from the action cache, which only a remote action
-// has an entry in.
-func cachedActionTar(ctx context.Context, step actionStep, name, includePrefix string) (io.ReadCloser, error) {
-	remote, ok := step.(*stepActionRemote)
-	if !ok {
-		return nil, fmt.Errorf("action %q is a remote action but runs as %T", name, step)
-	}
-	return step.getRunContext().Config.ActionCache.GetTarArchive(ctx, remote.cacheDir, remote.resolvedSha, includePrefix)
-}
-
 func maybeCopyToActionDir(ctx context.Context, step actionStep, actionDir, actionPath, containerActionDir string) error {
 	logger := common.Logger(ctx)
 	rc := step.getRunContext()
@@ -157,7 +147,8 @@ func maybeCopyToActionDir(ctx context.Context, step actionStep, actionDir, actio
 	}
 
 	if rc.Config != nil && rc.Config.ActionCache != nil {
-		ta, err := cachedActionTar(ctx, step, stepModel.Uses, "")
+		raction := step.(*stepActionRemote)
+		ta, err := rc.Config.ActionCache.GetTarArchive(ctx, raction.cacheDir, raction.resolvedSha, "")
 		if err != nil {
 			return err
 		}
@@ -216,7 +207,7 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
 			if remoteAction == nil {
 				location = containerActionDir
 			}
-			return execAsDocker(ctx, step, actionName, actionDir, location, remoteAction == nil, stepStageMain)
+			return execAsDocker(ctx, step, actionName, actionDir, location, remoteAction == nil)
 		case x.IsComposite():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
@@ -314,7 +305,7 @@ func dockerActionImageTag(repository, actionName string, localAction bool) strin
 }
 
 // TODO: break out parts of function to reduce complexicity
-func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, basedir string, localAction bool, stage stepStage) error {
+func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, basedir string, localAction bool) error {
 	logger := common.Logger(ctx)
 	rc := step.getRunContext()
 	action := step.getActionModel()
@@ -360,7 +351,8 @@ func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, b
 				}
 				defer buildContext.Close()
 			} else if rc.Config.ActionCache != nil {
-				buildContext, err = cachedActionTar(ctx, step, actionName, contextDir)
+				rstep := step.(*stepActionRemote)
+				buildContext, err = rc.Config.ActionCache.GetTarArchive(ctx, rstep.cacheDir, rstep.resolvedSha, contextDir)
 				if err != nil {
 					return err
 				}
@@ -372,7 +364,6 @@ func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, b
 				ImageTag:     image,
 				BuildContext: buildContext,
 				Platform:     rc.Config.ContainerArchitecture,
-				BuildArgs:    rc.proxyBuildArgs(),
 			})
 			if buildContext == nil {
 				// Held across the whole build: the daemon drains contextDir lazily.
@@ -395,9 +386,16 @@ func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, b
 		cmd = action.Runs.Args
 		evalDockerArgs(ctx, step, action, &cmd)
 	}
-	entrypoint, err := dockerEntrypoint(ctx, step, eval, stage)
+	entrypoint := strings.Fields(eval.Interpolate(ctx, step.getStepModel().With["entrypoint"]))
-	if err != nil {
+	if len(entrypoint) == 0 {
-		return err
+		if action.Runs.Entrypoint != "" {
+			entrypoint, err = shellquote.Split(action.Runs.Entrypoint)
+			if err != nil {
+				return err
+			}
+		} else {
+			entrypoint = nil
+		}
 	}
 	stepContainer := newStepContainer(ctx, step, image, cmd, entrypoint)
 	return common.NewPipelineExecutor(
@@ -407,34 +405,10 @@ func execAsDocker(ctx context.Context, step actionStep, actionName, actionDir, b
 		stepContainer.Create(rc.Config.ContainerCapAdd, rc.Config.ContainerCapDrop),
 		stepContainer.Start(true),
 	).Finally(
-		stepContainer.Remove().IfBool(!rc.Config.ReuseContainers && !rc.Config.AutoRemove),
+		stepContainer.Remove().IfBool(!rc.Config.ReuseContainers),
 	).Finally(stepContainer.Close())(ctx)
 }
 
-// dockerEntrypoint returns the entrypoint the action's image runs with for the given
-// stage. Only the main stage honours the `entrypoint` input.
-func dockerEntrypoint(ctx context.Context, step actionStep, eval ExpressionEvaluator, stage stepStage) ([]string, error) {
-	runs := step.getActionModel().Runs
-
-	var entrypoint string
-	switch stage {
-	case stepStagePre:
-		entrypoint = runs.PreEntrypoint
-	case stepStagePost:
-		entrypoint = runs.PostEntrypoint
-	default:
-		if fields := strings.Fields(eval.Interpolate(ctx, step.getStepModel().With["entrypoint"])); len(fields) > 0 {
-			return fields, nil
-		}
-		entrypoint = runs.Entrypoint
-	}
-
-	if entrypoint == "" {
-		return nil, nil
-	}
-	return shellquote.Split(entrypoint)
-}
-
 func evalDockerArgs(ctx context.Context, step step, action *model.Action, cmd *[]string) {
 	rc := step.getRunContext()
 	stepModel := step.getStepModel()
@@ -481,7 +455,10 @@ func newStepContainer(ctx context.Context, step step, image string, cmd, entrypo
 		envList = append(envList, fmt.Sprintf("%s=%s", k, v))
 	}
 
-	envList = append(envList, rc.runnerEnv(ctx)...)
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TOOL_CACHE", "/opt/hostedtoolcache"))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_OS", "Linux"))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_ARCH", container.RunnerArch(ctx)))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TEMP", "/tmp"))
 
 	binds, mounts := rc.GetBindsAndMounts()
 	networkMode := "container:" + rc.jobContainerName()
@@ -582,57 +559,44 @@ func hasPreStep(step actionStep) common.Conditional {
 		return action.Runs.Using.IsComposite() ||
 			(action.Runs.Using.IsNode() &&
 				action.Runs.Pre != "") ||
-			(action.Runs.Using.IsDocker() &&
-				action.Runs.PreEntrypoint != "") ||
 			(action.Runs.Using == model.ActionRunsUsingGo &&
 				action.Runs.Pre != "")
 	}
 }
 
-// actionStagePaths resolves where a step's action lives and where the job container sees
-// it, for the pre and post stage.
-func actionStagePaths(step actionStep) (actionDir, actionPath, actionName, containerActionDir string) {
-	rc := step.getRunContext()
-	stepModel := step.getStepModel()
-
-	if _, ok := step.(*stepActionRemote); ok {
-		actionDir = fmt.Sprintf("%s/%s", rc.ActionCacheDir(), stepModel.UsesHash())
-		actionPath = newRemoteAction(stepModel.Uses).Path
-	} else {
-		actionDir = filepath.Join(rc.Config.Workdir, stepModel.Uses)
-	}
-
-	actionName, containerActionDir = getContainerActionPaths(stepModel, path.Join(actionDir, actionPath), rc)
-	return actionDir, actionPath, actionName, containerActionDir
-}
-
-// execDockerActionStage runs a docker action's image for its pre or post stage.
-func execDockerActionStage(ctx context.Context, step actionStep, stage stepStage) error {
-	actionDir, actionPath, actionName, containerActionDir := actionStagePaths(step)
-
-	_, remote := step.(*stepActionRemote)
-	location := containerActionDir
-	if remote {
-		location = path.Join(actionDir, actionPath)
-	}
-	return execAsDocker(ctx, step, actionName, actionDir, location, !remote, stage)
-}
-
 func runPreStep(step actionStep) common.Executor {
 	return func(ctx context.Context) error {
 		logger := common.Logger(ctx)
 		logger.Debugf("run pre step for '%s'", step.getStepModel())
 
 		rc := step.getRunContext()
+		stepModel := step.getStepModel()
 		action := step.getActionModel()
 
-		actionDir, actionPath, _, containerActionDir := actionStagePaths(step)
-
 		x := action.Runs.Using
 		switch {
 		case x.IsNode():
 			// defaults in pre steps were missing, however provided inputs are available
 			populateEnvsFromInput(ctx, step.getEnv(), action, rc)
+			// todo: refactor into step
+			var actionDir string
+			var actionPath string
+			if _, ok := step.(*stepActionRemote); ok {
+				actionPath = newRemoteAction(stepModel.Uses).Path
+				actionDir = fmt.Sprintf("%s/%s", rc.ActionCacheDir(), stepModel.UsesHash())
+			} else {
+				actionDir = filepath.Join(rc.Config.Workdir, stepModel.Uses)
+				actionPath = ""
+			}
+
+			var actionLocation string
+			if actionPath != "" {
+				actionLocation = path.Join(actionDir, actionPath)
+			} else {
+				actionLocation = actionDir
+			}
+
+			_, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
 
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
@@ -645,12 +609,6 @@ func runPreStep(step actionStep) common.Executor {
 
 			return rc.execJobContainer(containerArgs, *step.getEnv(), "", "")(ctx)
 
-		case x.IsDocker():
-			// defaults in pre steps were missing, however provided inputs are available
-			populateEnvsFromInput(ctx, step.getEnv(), action, rc)
-
-			return execDockerActionStage(ctx, step, stepStagePre)
-
 		case x.IsComposite():
 			if step.getCompositeSteps() == nil {
 				step.getCompositeRunContext(ctx)
@@ -664,6 +622,25 @@ func runPreStep(step actionStep) common.Executor {
 		case x == model.ActionRunsUsingGo:
 			// defaults in pre steps were missing, however provided inputs are available
 			populateEnvsFromInput(ctx, step.getEnv(), action, rc)
+			// todo: refactor into step
+			var actionDir string
+			var actionPath string
+			if _, ok := step.(*stepActionRemote); ok {
+				actionPath = newRemoteAction(stepModel.Uses).Path
+				actionDir = fmt.Sprintf("%s/%s", rc.ActionCacheDir(), stepModel.UsesHash())
+			} else {
+				actionDir = filepath.Join(rc.Config.Workdir, stepModel.Uses)
+				actionPath = ""
+			}
+
+			var actionLocation string
+			if actionPath != "" {
+				actionLocation = path.Join(actionDir, actionPath)
+			} else {
+				actionLocation = actionDir
+			}
+
+			_, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
 
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err
@@ -716,8 +693,6 @@ func hasPostStep(step actionStep) common.Conditional {
 		return action.Runs.Using.IsComposite() ||
 			(action.Runs.Using.IsNode() &&
 				action.Runs.Post != "") ||
-			(action.Runs.Using.IsDocker() &&
-				action.Runs.PostEntrypoint != "") ||
 			(action.Runs.Using == model.ActionRunsUsingGo &&
 				action.Runs.Post != "")
 	}
@@ -729,9 +704,28 @@ func runPostStep(step actionStep) common.Executor {
 		logger.Debugf("run post step for '%s'", step.getStepModel())
 
 		rc := step.getRunContext()
+		stepModel := step.getStepModel()
 		action := step.getActionModel()
 
-		actionDir, actionPath, _, containerActionDir := actionStagePaths(step)
+		// todo: refactor into step
+		var actionDir string
+		var actionPath string
+		if _, ok := step.(*stepActionRemote); ok {
+			actionPath = newRemoteAction(stepModel.Uses).Path
+			actionDir = fmt.Sprintf("%s/%s", rc.ActionCacheDir(), stepModel.UsesHash())
+		} else {
+			actionDir = filepath.Join(rc.Config.Workdir, stepModel.Uses)
+			actionPath = ""
+		}
+
+		var actionLocation string
+		if actionPath != "" {
+			actionLocation = path.Join(actionDir, actionPath)
+		} else {
+			actionLocation = actionDir
+		}
+
+		_, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
 
 		x := action.Runs.Using
 		switch {
@@ -746,11 +740,6 @@ func runPostStep(step actionStep) common.Executor {
 
 			return rc.execJobContainer(containerArgs, *step.getEnv(), "", "")(ctx)
 
-		case x.IsDocker():
-			populateEnvsFromSavedState(step.getEnv(), step, rc)
-
-			return execDockerActionStage(ctx, step, stepStagePost)
-
 		case x.IsComposite():
 			if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
 				return err

act/runner/action_test.go

@@ -20,7 +20,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 type closerMock struct {
@@ -151,44 +150,6 @@ runs:
 	}
 }
 
-// With AutoRemove the daemon reaps the container on exit, so act must not remove it afterwards.
-func TestExecAsDockerAutoRemove(t *testing.T) {
-	orig := ContainerNewContainer
-	defer func() { ContainerNewContainer = orig }()
-
-	for _, tc := range []struct {
-		autoRemove bool
-		removes    int
-	}{
-		{false, 2}, // stale + post-run
-		{true, 1},  // post-run skipped
-	} {
-		cm := &containerMock{}
-		ContainerNewContainer = func(*container.NewContainerInput) container.ExecutionsEnvironment { return cm }
-
-		step := &stepActionRemote{
-			Step: &model.Step{ID: "1", Uses: "org/action@v1"},
-			RunContext: &RunContext{
-				Config:       &Config{AutoRemove: tc.autoRemove},
-				Run:          &model.Run{JobID: "1", Workflow: &model.Workflow{Jobs: map[string]*model.Job{"1": {}}}},
-				JobContainer: cm,
-			},
-			action: &model.Action{Runs: model.ActionRuns{Using: "docker", Image: "docker://node:14"}},
-		}
-
-		removes := 0
-		cm.On("Pull", false).Return(func(context.Context) error { return nil })
-		cm.On("Remove").Return(func(context.Context) error { removes++; return nil })
-		cm.On("Create", []string(nil), []string(nil)).Return(func(context.Context) error { return nil })
-		cm.On("Start", true).Return(func(context.Context) error { return nil })
-		cm.On("Close").Return(func(context.Context) error { return nil })
-
-		require.NoError(t, execAsDocker(context.Background(), step, "action", t.TempDir(), t.TempDir(), false, stepStageMain))
-		cm.AssertExpectations(t)
-		assert.Equal(t, tc.removes, removes)
-	}
-}
-
 func TestActionRunner(t *testing.T) {
 	table := []struct {
 		name        string
@@ -465,7 +426,7 @@ func TestExecAsDockerHoldsCloneLockForRemoteUncached(t *testing.T) {
 	defer cancel()
 
 	done := make(chan error, 1)
-	go func() { done <- execAsDocker(ctx, step, "test-action", actionDir, actionDir, false, stepStageMain) }()
+	go func() { done <- execAsDocker(ctx, step, "test-action", actionDir, actionDir, false) }()
 
 	select {
 	case <-innerEntered:
@@ -541,86 +502,3 @@ func TestDockerActionImageTag(t *testing.T) {
 		dockerActionImageTag("owner/repo", "./sub", true),
 	)
 }
-
-// Only the entrypoint is stage specific: every stage of a docker action receives runs.args
-// and runs.env, and the `entrypoint` input applies to the main stage alone.
-func TestExecAsDockerStageEntrypoint(t *testing.T) {
-	orig := ContainerNewContainer
-	defer func() { ContainerNewContainer = orig }()
-
-	for _, tc := range []struct {
-		name           string
-		stage          stepStage
-		wantEntrypoint []string
-	}{
-		{
-			name:           "main stage prefers the entrypoint input",
-			stage:          stepStageMain,
-			wantEntrypoint: []string{"input.sh"},
-		},
-		{
-			name:           "pre stage uses runs.pre-entrypoint",
-			stage:          stepStagePre,
-			wantEntrypoint: []string{"pre.sh", "--verbose"},
-		},
-		{
-			name:           "post stage uses runs.post-entrypoint",
-			stage:          stepStagePost,
-			wantEntrypoint: []string{"post.sh"},
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			cm := &containerMock{}
-			var input *container.NewContainerInput
-			ContainerNewContainer = func(in *container.NewContainerInput) container.ExecutionsEnvironment {
-				input = in
-				return cm
-			}
-
-			step := &stepActionRemote{
-				Step: &model.Step{ID: "1", Uses: "org/action@v1", With: map[string]string{"entrypoint": "input.sh"}},
-				RunContext: &RunContext{
-					Config:       &Config{},
-					Run:          &model.Run{JobID: "1", Workflow: &model.Workflow{Jobs: map[string]*model.Job{"1": {}}}},
-					JobContainer: cm,
-				},
-				action: &model.Action{Runs: model.ActionRuns{
-					Using:          "docker",
-					Image:          "docker://node:14",
-					PreEntrypoint:  "pre.sh --verbose",
-					Entrypoint:     "main.sh",
-					PostEntrypoint: "post.sh",
-					Args:           []string{"hello"},
-					Env:            map[string]string{"MY_VAR": "world"},
-				}},
-				env: map[string]string{},
-			}
-
-			cm.On("Pull", false).Return(func(context.Context) error { return nil })
-			cm.On("Remove").Return(func(context.Context) error { return nil })
-			cm.On("Create", []string(nil), []string(nil)).Return(func(context.Context) error { return nil })
-			cm.On("Start", true).Return(func(context.Context) error { return nil })
-			cm.On("Close").Return(func(context.Context) error { return nil })
-
-			require.NoError(t, execAsDocker(context.Background(), step, "action", t.TempDir(), t.TempDir(), false, tc.stage))
-			require.NotNil(t, input)
-			assert.Equal(t, tc.wantEntrypoint, input.Entrypoint)
-			assert.Equal(t, []string{"hello"}, input.Cmd)
-			assert.Contains(t, input.Env, "MY_VAR=world")
-		})
-	}
-}
-
-func TestDockerActionHasPreAndPostStep(t *testing.T) {
-	newStep := func(runs model.ActionRuns) actionStep {
-		return &stepActionRemote{action: &model.Action{Runs: runs}}
-	}
-	ctx := context.Background()
-
-	assert.False(t, hasPreStep(newStep(model.ActionRuns{Using: "docker", Image: "Dockerfile"}))(ctx))
-	assert.False(t, hasPostStep(newStep(model.ActionRuns{Using: "docker", Image: "Dockerfile"}))(ctx))
-
-	withStages := model.ActionRuns{Using: "docker", Image: "Dockerfile", PreEntrypoint: "pre.sh", PostEntrypoint: "post.sh"}
-	assert.True(t, hasPreStep(newStep(withStages))(ctx))
-	assert.True(t, hasPostStep(newStep(withStages))(ctx))
-}

act/runner/cancellation_test.go

@@ -283,30 +283,3 @@ func TestPostStepsContextDeadlinePreservesJobError(t *testing.T) {
 	require.NoError(t, postCtx.Err(), "post context must not carry the expired deadline")
 	assert.ErrorIs(t, common.JobError(postCtx), assert.AnError, "the timeout job error must be preserved")
 }
-
-// reportStepError must treat a context.Canceled (e.g. a teardown-cancelled read) as an
-// interruption, never a job failure.
-func TestReportStepErrorTreatsCancelAsInterruption(t *testing.T) {
-	rc := &RunContext{}
-
-	// stray read cancellation while the job context is live: ignored, not a failure
-	live := common.WithJobErrorContainer(context.Background())
-	reportStepError(live, rc, context.Canceled)
-	require.NoError(t, common.JobError(live))
-	assert.False(t, rc.jobFailed)
-	assert.False(t, rc.jobCancelled)
-
-	// genuine job cancellation: recorded as cancelled, still not a failure
-	cancelled, cancel := context.WithCancel(common.WithJobErrorContainer(context.Background()))
-	cancel()
-	reportStepError(cancelled, rc, context.Canceled)
-	require.NoError(t, common.JobError(cancelled))
-	assert.False(t, rc.jobFailed)
-	assert.True(t, rc.jobCancelled)
-
-	// a real error still fails the job
-	failed := common.WithJobErrorContainer(context.Background())
-	reportStepError(failed, rc, assert.AnError)
-	require.ErrorIs(t, common.JobError(failed), assert.AnError)
-	assert.True(t, rc.jobFailed)
-}

act/runner/command.go

@@ -154,25 +154,30 @@ func parseKeyValuePairs(kvPairs, separator string) map[string]string {
 	return rtn
 }
 
-// A Replacer never rescans what it wrote, so "%250A" stays a literal "%0A".
-var (
-	commandDataEscaper       = strings.NewReplacer("%", "%25", "\r", "%0D", "\n", "%0A")
-	commandDataUnescaper     = strings.NewReplacer("%25", "%", "%0D", "\r", "%0A", "\n")
-	commandPropertyUnescaper = strings.NewReplacer("%25", "%", "%0D", "\r", "%0A", "\n", "%3A", ":", "%2C", ",")
-)
-
-// escapeCommandData encodes the data part of a "::cmd::" or "##[cmd]" line the runner writes itself,
-// so the log renderer decodes it back. Lines forwarded from step output are already escaped.
-func escapeCommandData(arg string) string {
-	return commandDataEscaper.Replace(arg)
-}
-
 func UnescapeCommandData(arg string) string {
-	return commandDataUnescaper.Replace(arg)
+	escapeMap := map[string]string{
+		"%25": "%",
+		"%0D": "\r",
+		"%0A": "\n",
+	}
+	for k, v := range escapeMap {
+		arg = strings.ReplaceAll(arg, k, v)
+	}
+	return arg
 }
 
 func unescapeCommandProperty(arg string) string {
-	return commandPropertyUnescaper.Replace(arg)
+	escapeMap := map[string]string{
+		"%25": "%",
+		"%0D": "\r",
+		"%0A": "\n",
+		"%3A": ":",
+		"%2C": ",",
+	}
+	for k, v := range escapeMap {
+		arg = strings.ReplaceAll(arg, k, v)
+	}
+	return arg
 }
 
 func unescapeKvPairs(kvPairs map[string]string) map[string]string {

act/runner/command_test.go

@@ -214,10 +214,3 @@ func TestSaveState(t *testing.T) {
 
 	assert.Equal(t, "state-value", rc.IntraActionState["step"]["state-name"])
 }
-
-func TestEscapeCommandData(t *testing.T) {
-	a := assert.New(t)
-
-	a.Equal("a%25b%0Dc%0Ad%250A", escapeCommandData("a%b\rc\nd%0A"))
-	a.Equal("a%b\rc\nd%0A", UnescapeCommandData("a%25b%0Dc%0Ad%250A"))
-}

act/runner/expression.go

@@ -95,7 +95,9 @@ func (rc *RunContext) NewExpressionEvaluatorWithEnv(ctx context.Context, env map
 		Inputs:    inputs,
 		HashFiles: getHashFilesFunction(ctx, rc),
 	}
-	ee.Runner = rc.getRunnerContext(ctx)
+	if rc.JobContainer != nil {
+		ee.Runner = rc.JobContainer.GetRunnerContext(ctx)
+	}
 	return expressionEvaluator{
 		interpreter: exprparser.NewInterpeter(ee, exprparser.Config{
 			Run:        rc.Run,
@@ -147,7 +149,9 @@ func (rc *RunContext) NewStepExpressionEvaluator(ctx context.Context, step step)
 		Inputs:    inputs,
 		HashFiles: getHashFilesFunction(ctx, rc),
 	}
-	ee.Runner = rc.getRunnerContext(ctx)
+	if rc.JobContainer != nil {
+		ee.Runner = rc.JobContainer.GetRunnerContext(ctx)
+	}
 	return expressionEvaluator{
 		interpreter: exprparser.NewInterpeter(ee, exprparser.Config{
 			Run:        rc.Run,
@@ -225,8 +229,7 @@ func (ee expressionEvaluator) evaluate(ctx context.Context, in string, defaultSt
 	logger.Debugf("evaluating expression '%s'", in)
 	evaluated, err := ee.interpreter.Evaluate(in, defaultStatusCheck)
 
-	// evaluated is an any: %t renders everything but a bool as "%!t(string=...)"
+	printable := regexp.MustCompile(`::add-mask::.*`).ReplaceAllString(fmt.Sprintf("%t", evaluated), "::add-mask::***)")
-	printable := regexp.MustCompile(`::add-mask::.*`).ReplaceAllString(fmt.Sprintf("%v", evaluated), "::add-mask::***)")
 	logger.Debugf("expression '%s' evaluated to '%s'", in, printable)
 
 	return evaluated, err
@@ -494,7 +497,11 @@ func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *mod
 				if value == nil {
 					value = v.Default
 				}
-				inputs[k] = coerceInputValue(value, v.Type)
+				if v.Type == "boolean" {
+					inputs[k] = value == "true"
+				} else {
+					inputs[k] = value
+				}
 			}
 		}
 	}
@@ -507,26 +514,17 @@ func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *mod
 				if value == nil {
 					value = v.Default
 				}
-				inputs[k] = coerceInputValue(value, v.Type)
+				if v.Type == "boolean" {
+					inputs[k] = value == "true"
+				} else {
+					inputs[k] = value
+				}
 			}
 		}
 	}
 	return inputs
 }
 
-// coerceInputValue converts an input value to the type declared by the workflow.
-// The event payload carries natively typed JSON values on newer Gitea versions,
-// while defaults and older servers provide strings.
-func coerceInputValue(value any, inputType string) any {
-	if inputType != "boolean" {
-		return value
-	}
-	if b, ok := value.(bool); ok {
-		return b
-	}
-	return value == "true"
-}
-
 func setupWorkflowInputs(ctx context.Context, inputs *map[string]any, rc *RunContext) {
 	if rc.caller != nil {
 		config := rc.Run.Workflow.WorkflowCallConfig()
@@ -550,7 +548,7 @@ func setupWorkflowInputs(ctx context.Context, inputs *map[string]any, rc *RunCon
 				}
 			}
 
-			(*inputs)[name] = coerceInputValue(value, input.Type)
+			(*inputs)[name] = value
 		}
 	}
 }

act/runner/expression_test.go

@@ -6,14 +6,12 @@ package runner
 
 import (
 	"context"
-	"strings"
 	"testing"
 
 	"gitea.com/gitea/runner/act/exprparser"
 	"gitea.com/gitea/runner/act/model"
 
 	assert "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	yaml "go.yaml.in/yaml/v4"
 )
 
@@ -323,82 +321,3 @@ func TestRewriteSubExpressionForceFormat(t *testing.T) {
 		})
 	}
 }
-
-func TestGetEvaluatorInputsBoolean(t *testing.T) {
-	workflows := map[string]string{
-		"workflow_call": `
-on:
-  workflow_call:
-    inputs:
-      flag:
-        type: boolean
-        default: true
-      name:
-        type: string
-        default: gitea
-`,
-		"workflow_dispatch": `
-on:
-  workflow_dispatch:
-    inputs:
-      flag:
-        type: boolean
-        default: true
-      name:
-        type: string
-        default: gitea
-`,
-	}
-
-	tables := []struct {
-		name  string
-		event map[string]any
-		flag  any
-	}{
-		{
-			// Gitea >= 1.27 resolves the inputs server-side and sends native JSON types
-			name:  "native bool true",
-			event: map[string]any{"inputs": map[string]any{"flag": true}},
-			flag:  true,
-		},
-		{
-			name:  "native bool false",
-			event: map[string]any{"inputs": map[string]any{"flag": false}},
-			flag:  false,
-		},
-		{
-			name:  "string true",
-			event: map[string]any{"inputs": map[string]any{"flag": "true"}},
-			flag:  true,
-		},
-		{
-			name:  "string false",
-			event: map[string]any{"inputs": map[string]any{"flag": "false"}},
-			flag:  false,
-		},
-		{
-			name:  "default is used when the event carries no inputs",
-			event: map[string]any{},
-			flag:  true,
-		},
-	}
-
-	for eventName, workflow := range workflows {
-		for _, table := range tables {
-			t.Run(eventName+"/"+table.name, func(t *testing.T) {
-				wf, err := model.ReadWorkflow(strings.NewReader(workflow))
-				require.NoError(t, err)
-
-				rc := &RunContext{
-					Config: &Config{Workdir: "."},
-					Run:    &model.Run{JobID: "job1", Workflow: wf},
-				}
-				ghc := &model.GithubContext{EventName: eventName, Event: table.event}
-
-				inputs := getEvaluatorInputs(context.Background(), rc, nil, ghc)
-				assert.Equal(t, table.flag, inputs["flag"])
-				assert.Equal(t, "gitea", inputs["name"])
-			})
-		}
-	}
-}

act/runner/helpers_test.go

@@ -5,9 +5,11 @@ package runner
 
 import (
 	"context"
+	"net"
 	"os/exec"
 	"runtime"
 	"testing"
+	"time"
 
 	"gitea.com/gitea/runner/act/container"
 
@@ -40,6 +42,18 @@ func requireDocker(t *testing.T) {
 	}
 }
 
+// requireNetwork skips the test unless github.com is reachable. A few tests exercise behaviour
+// that inherently needs the network (force-pulling an image, resolving a remote short-sha ref);
+// gating lets the rest of the suite run offline without these failing.
+func requireNetwork(t *testing.T) {
+	t.Helper()
+	conn, err := net.DialTimeout("tcp", "github.com:443", 3*time.Second)
+	if err != nil {
+		t.Skipf("skipping: network unavailable: %v", err)
+	}
+	_ = conn.Close()
+}
+
 // requireHostTools skips the test unless every named executable is on PATH. Used by the
 // self-hosted (host environment) suite, which runs steps directly on the host.
 func requireHostTools(t *testing.T, tools ...string) {

act/runner/job_executor.go

@@ -10,7 +10,6 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -57,81 +56,17 @@ type jobInfo interface {
 	result(result string)
 }
 
-// reportStepError records a step error so the job is reported failed — except a
+// reportStepError emits the GitHub Actions ##[error] annotation and records
-// cancellation, which is an interruption, not a failure.
+// the error against the job so the job is reported as failed.
 func reportStepError(ctx context.Context, rc *RunContext, err error) {
-	if errors.Is(err, context.Canceled) {
+	common.Logger(ctx).Errorf("##[error]%v", err)
-		// Defer to the job context: a genuine cancel reports cancelled, a stray teardown
-		// cancellation on a live ctx is ignored — never a step FAILURE.
-		rc.markInterrupted(ctx.Err())
-		return
-	}
-	common.Logger(ctx).Errorf("##[error]%s", escapeCommandData(err.Error()))
 	common.SetJobError(ctx, err)
 	rc.markFailed()
 }
 
-// actionPreparer is implemented by steps that download an action before they run, so the job
-// executor can fetch all of them up front.
-type actionPreparer interface {
-	prepareActionExecutor() common.Executor
-	actionDownloadInfo() (reference, sha string, ok bool)
-}
-
-// printPrepareActions downloads every action the job uses before its first step runs and reports
-// them as actions/runner's "Prepare all required actions" section does. The steps still call
-// prepareActionExecutor themselves; it is a no-op once the action is resolved here.
-func printPrepareActions(rc *RunContext, preparers []actionPreparer) common.Executor {
-	return func(ctx context.Context) error {
-		if len(preparers) == 0 {
-			return nil
-		}
-
-		rawLogger := common.Logger(ctx).WithField(rawOutputField, true)
-		rawLogger.Infof("Prepare all required actions")
-
-		for _, preparer := range preparers {
-			if err := preparer.prepareActionExecutor()(ctx); err != nil {
-				// No step has run yet, so the failure belongs to the job.
-				reportStepError(ctx, rc, err)
-				return err
-			}
-			reference, sha, ok := preparer.actionDownloadInfo()
-			if !ok {
-				continue
-			}
-			if sha == "" {
-				rawLogger.Infof("Download action repository '%s'", reference)
-			} else {
-				rawLogger.Infof("Download action repository '%s' (SHA:%s)", reference, sha)
-			}
-		}
-		return nil
-	}
-}
-
-// printCompleteJobName closes the setup section the way actions/runner ends its "Set up job" step.
-func printCompleteJobName(rc *RunContext) common.Executor {
-	return func(ctx context.Context) error {
-		// Name holds a matrix combination; JobName is the shared name GitHub reports.
-		name := rc.JobName
-		if name == "" {
-			name = rc.Name
-		}
-		if name == "" && rc.Run != nil {
-			name = rc.Run.JobID
-		}
-		common.Logger(ctx).WithField(rawOutputField, true).Infof("Complete job name: %s", name)
-		return nil
-	}
-}
-
 func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executor {
 	steps := make([]common.Executor, 0)
 	preSteps := make([]common.Executor, 0)
-	// Collected separately: every action is downloaded before the first pre step runs.
-	stepPreSteps := make([]common.Executor, 0)
-	preparers := make([]actionPreparer, 0)
 	var postExecutor common.Executor
 
 	steps = append(steps, func(ctx context.Context) error {
@@ -178,13 +113,9 @@ func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executo
 			return common.NewErrorExecutor(err)
 		}
 
-		if preparer, ok := step.(actionPreparer); ok {
-			preparers = append(preparers, preparer)
-		}
-
 		stepIdx := stepModel.Number
 		preExec := step.pre()
-		stepPreSteps = append(stepPreSteps, useStepLogger(rc, stepModel, stepStagePre, func(ctx context.Context) error {
+		preSteps = append(preSteps, useStepLogger(rc, stepModel, stepStagePre, func(ctx context.Context) error {
 			rc.CurrentStepIndex = stepIdx
 			preErr := preExec(ctx)
 			if preErr != nil {
@@ -226,16 +157,6 @@ func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executo
 		}
 	}
 
-	// The setup section of the job log. The started hook goes first, so what it sets up is
-	// in place for the first action download and the first step.
-	preSteps = append(preSteps, rc.runJobStartedHook)
-	preSteps = append(preSteps, printPrepareActions(rc, preparers))
-	preSteps = append(preSteps, stepPreSteps...)
-	preSteps = append(preSteps, printCompleteJobName(rc))
-
-	// Ahead of the teardown below, while the job environment is still up.
-	postExecutor = postExecutor.Finally(rc.runJobCompletedHook)
-
 	postExecutor = postExecutor.Finally(func(ctx context.Context) error {
 		jobError := common.JobError(ctx)
 		var err error

act/runner/job_executor_test.go

@@ -24,7 +24,6 @@ import (
 	"gitea.com/gitea/runner/act/container"
 	"gitea.com/gitea/runner/act/model"
 
-	log "github.com/sirupsen/logrus"
 	logrustest "github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -33,7 +32,6 @@ import (
 )
 
 func TestJobExecutor(t *testing.T) {
-	t.Parallel()
 	// Dryrun only checks syntax/planning; all cases resolve locally, so this runs offline.
 	tables := []TestJobFileInfo{
 		{workdir, "uses-and-run-in-one-step", "push", "Invalid run/uses syntax for job:test step:Test", platforms, secrets},
@@ -47,7 +45,6 @@ func TestJobExecutor(t *testing.T) {
 	ctx := common.WithDryrun(context.Background(), true)
 	for _, table := range tables {
 		t.Run(table.workflowPath, func(t *testing.T) {
-			t.Parallel()
 			table.runTest(ctx, t, &Config{})
 		})
 	}
@@ -114,182 +111,6 @@ func (sfm *stepFactoryMock) newStep(model *model.Step, rc *RunContext) (step, er
 	return args.Get(0).(step), args.Error(1)
 }
 
-// actionPreparerMock stands in for a step whose action is downloaded before the job's first step.
-type actionPreparerMock struct {
-	reference string
-	sha       string
-	ok        bool
-	err       error
-	prepared  int
-}
-
-func (apm *actionPreparerMock) prepareActionExecutor() common.Executor {
-	return func(context.Context) error {
-		apm.prepared++
-		return apm.err
-	}
-}
-
-func (apm *actionPreparerMock) actionDownloadInfo() (string, string, bool) {
-	return apm.reference, apm.sha, apm.ok
-}
-
-func TestPrintPrepareActionsGolden(t *testing.T) {
-	buf := &bytes.Buffer{}
-	logger := log.New()
-	logger.SetOutput(buf)
-	logger.SetLevel(log.InfoLevel)
-	logger.SetFormatter(&jobLogFormatter{color: cyan})
-	ctx := common.WithLogger(context.Background(), logger.WithFields(log.Fields{"job": "j1"}))
-
-	preparers := []actionPreparer{
-		&actionPreparerMock{reference: "actions/checkout@v7", sha: "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0", ok: true},
-		// A resolved commit is best effort; the ref alone is reported when it is unknown.
-		&actionPreparerMock{reference: "actions/setup-go@v6", ok: true},
-		// A step that downloads nothing, such as the checkout of the workflow's own repository.
-		&actionPreparerMock{ok: false},
-	}
-	require.NoError(t, printPrepareActions(&RunContext{}, preparers)(ctx))
-
-	want := strings.Join([]string{
-		"[j1]   | Prepare all required actions",
-		"[j1]   | Download action repository 'actions/checkout@v7' (SHA:9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0)",
-		"[j1]   | Download action repository 'actions/setup-go@v6'",
-		"",
-	}, "\n")
-	assert.Equal(t, want, buf.String())
-}
-
-func TestPrintPrepareActionsSkipsWithoutActions(t *testing.T) {
-	buf := &bytes.Buffer{}
-	logger := log.New()
-	logger.SetOutput(buf)
-	logger.SetFormatter(&jobLogFormatter{color: cyan})
-	ctx := common.WithLogger(context.Background(), logger.WithFields(log.Fields{"job": "j1"}))
-
-	require.NoError(t, printPrepareActions(&RunContext{}, nil)(ctx))
-
-	assert.Empty(t, buf.String())
-}
-
-func TestPrintPrepareActionsFailsJobOnDownloadError(t *testing.T) {
-	logger, _ := logrustest.NewNullLogger()
-	ctx := common.WithJobErrorContainer(common.WithLogger(context.Background(), logger.WithField("job", "j1")))
-
-	downloadErr := errors.New("failed to fetch \"actions/checkout\"")
-	rc := &RunContext{}
-	remaining := &actionPreparerMock{reference: "actions/setup-go@v6", ok: true}
-
-	err := printPrepareActions(rc, []actionPreparer{
-		&actionPreparerMock{err: downloadErr},
-		remaining,
-	})(ctx)
-
-	require.ErrorIs(t, err, downloadErr)
-	// No step has run yet, so the failure has to be recorded against the job itself.
-	assert.Equal(t, downloadErr, common.JobError(ctx))
-	assert.True(t, rc.jobFailed)
-	assert.Zero(t, remaining.prepared)
-}
-
-func TestPrintCompleteJobName(t *testing.T) {
-	for name, tt := range map[string]struct {
-		rc   *RunContext
-		want string
-	}{
-		"job name":            {rc: &RunContext{JobName: "lint", Name: "lint-1"}, want: "lint"},
-		"falls back to name":  {rc: &RunContext{Name: "lint-1"}, want: "lint-1"},
-		"falls back to jobID": {rc: &RunContext{Run: &model.Run{JobID: "lint"}}, want: "lint"},
-	} {
-		t.Run(name, func(t *testing.T) {
-			buf := &bytes.Buffer{}
-			logger := log.New()
-			logger.SetOutput(buf)
-			logger.SetFormatter(&jobLogFormatter{color: cyan})
-			ctx := common.WithLogger(context.Background(), logger.WithFields(log.Fields{"job": "j1"}))
-
-			require.NoError(t, printCompleteJobName(tt.rc)(ctx))
-
-			assert.Equal(t, "[j1]   | Complete job name: "+tt.want+"\n", buf.String())
-		})
-	}
-}
-
-// actionStepMock is a step whose action has to be downloaded before it can run.
-type actionStepMock struct {
-	*stepMock
-	*actionPreparerMock
-}
-
-// TestNewJobExecutorDownloadsAllActionsBeforeTheFirstStep pins the shape of the setup section:
-// every action is downloaded before any step runs, and the job name closes the section. A pre
-// step that downloaded its own action would leave the log interleaved with the downloads.
-func TestNewJobExecutorDownloadsAllActionsBeforeTheFirstStep(t *testing.T) {
-	ctx := common.WithJobErrorContainer(context.Background())
-	jim := &jobInfoMock{}
-	sfm := &stepFactoryMock{}
-	rc := &RunContext{
-		JobContainer: &jobContainerMock{},
-		Run: &model.Run{
-			JobID: "test",
-			Workflow: &model.Workflow{
-				Jobs: map[string]*model.Job{"test": {}},
-			},
-		},
-		Config: &Config{},
-	}
-	rc.ExprEval = rc.NewExpressionEvaluator(ctx)
-
-	steps := []*model.Step{{ID: "1"}, {ID: "2"}}
-	executorOrder := make([]string, 0)
-
-	jim.On("steps").Return(steps)
-	jim.On("matrix").Return(map[string]any{})
-	jim.On("startContainer").Return(func(context.Context) error { return nil })
-	jim.On("stopContainer").Return(func(context.Context) error { return nil })
-	jim.On("closeContainer").Return(func(context.Context) error { return nil })
-	jim.On("interpolateOutputs").Return(func(context.Context) error { return nil })
-	jim.On("result", "success")
-
-	for _, stepModel := range steps {
-		sm := &stepMock{}
-		apm := &actionPreparerMock{reference: "actions/checkout@v" + stepModel.ID, ok: true}
-		sfm.On("newStep", stepModel, rc).Return(&actionStepMock{stepMock: sm, actionPreparerMock: apm}, nil)
-
-		sm.On("pre").Return(func(context.Context) error {
-			executorOrder = append(executorOrder, "pre"+stepModel.ID)
-			return nil
-		})
-		sm.On("main").Return(func(context.Context) error {
-			executorOrder = append(executorOrder, "step"+stepModel.ID)
-			return nil
-		})
-		sm.On("post").Return(func(context.Context) error { return nil })
-
-		defer sm.AssertExpectations(t)
-	}
-
-	logger, hook := logrustest.NewNullLogger()
-	err := newJobExecutor(jim, sfm, rc)(common.WithLogger(ctx, logger.WithField("job", "test")))
-	require.NoError(t, err)
-
-	assert.Equal(t, []string{"pre1", "pre2", "step1", "step2"}, executorOrder)
-
-	setup := make([]string, 0)
-	for _, entry := range hook.AllEntries() {
-		if strings.HasPrefix(entry.Message, "Prepare all required actions") || strings.HasPrefix(entry.Message, "Download action") ||
-			strings.HasPrefix(entry.Message, "Complete job name") {
-			setup = append(setup, entry.Message)
-		}
-	}
-	assert.Equal(t, []string{
-		"Prepare all required actions",
-		"Download action repository 'actions/checkout@v1'",
-		"Download action repository 'actions/checkout@v2'",
-		"Complete job name: test",
-	}, setup)
-}
-
 func TestNewJobExecutor(t *testing.T) {
 	table := []struct {
 		name          string

act/runner/job_hooks.go

@@ -1,115 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runner
-
-import (
-	"cmp"
-	"context"
-	"fmt"
-	"maps"
-	"path"
-	"strings"
-
-	"gitea.com/gitea/runner/act/common"
-	"gitea.com/gitea/runner/act/container"
-)
-
-// GitHub's job-hook variables, read as a fallback when the settings are unset.
-const (
-	jobStartedHookEnv   = "ACTIONS_RUNNER_HOOK_JOB_STARTED"
-	jobCompletedHookEnv = "ACTIONS_RUNNER_HOOK_JOB_COMPLETED"
-)
-
-// Kept apart from the per-step file-command files, which are truncated on every step.
-const (
-	hookEnvFileCommand  = "workflow/hook-envs.txt"
-	hookPathFileCommand = "workflow/hook-path.txt"
-)
-
-func (rc *RunContext) runJobStartedHook(ctx context.Context) error {
-	return rc.runJobHook(ctx, cmp.Or(rc.Config.JobStartedHook, rc.Config.Env[jobStartedHookEnv]), "job started")
-}
-
-func (rc *RunContext) runJobCompletedHook(ctx context.Context) error {
-	return rc.runJobHook(ctx, cmp.Or(rc.Config.JobCompletedHook, rc.Config.Env[jobCompletedHookEnv]), "job completed")
-}
-
-// runJobHook runs one hook in the job environment. Either hook failing fails the job, as
-// on GitHub, where the operator is responsible for the hook's own resilience.
-func (rc *RunContext) runJobHook(ctx context.Context, hookPath, name string) error {
-	if hookPath == "" {
-		return nil
-	}
-
-	cmd, shell := hookCommand(hookPath)
-	rawLogger := common.Logger(ctx).WithField(rawOutputField, true)
-	defer rawLogger.Infof("::endgroup::")
-	rawLogger.Infof("::group::Run '%s'", escapeCommandData(hookPath))
-	rawLogger.Infof("A %s hook has been configured by the runner administrator", name)
-	if shell != "" {
-		rawLogger.Infof("shell: %s", shell)
-	}
-
-	env := maps.Clone(rc.GetEnv())
-	if jobContainer := rc.Run.Job().Container(); jobContainer != nil {
-		maps.Copy(env, jobContainer.Env)
-	}
-	rc.withGithubEnv(ctx, rc.getGithubContext(ctx), env)
-	rc.ApplyExtraPath(ctx, &env)
-
-	err := rc.setupHookFileCommands(ctx, env)
-	if err == nil {
-		err = rc.JobContainer.Exec(cmd, env, "", "")(ctx)
-	}
-	// Processed even on failure, so a hook that exports what it managed to set up before
-	// failing still hands it to the job.
-	err = cmp.Or(err, rc.processHookFileCommands(ctx))
-	if err == nil {
-		return nil
-	}
-
-	err = fmt.Errorf("the %s hook %q failed: %w", name, hookPath, err)
-	// Flip the job status the way a failing pre step does, so success()-default main steps
-	// skip and the task is reported failed.
-	reportStepError(ctx, rc, err)
-	return err
-}
-
-// setupHookFileCommands points the hook at its GITHUB_ENV and GITHUB_PATH files, so it can
-// export to the job's steps, and truncates them so the second hook does not re-read what
-// the first one wrote.
-func (rc *RunContext) setupHookFileCommands(ctx context.Context, env map[string]string) error {
-	actPath := rc.JobContainer.GetActPath()
-	env["GITHUB_ENV"] = path.Join(actPath, hookEnvFileCommand)
-	env["GITHUB_PATH"] = path.Join(actPath, hookPathFileCommand)
-	env["GITEA_ENV"] = env["GITHUB_ENV"]
-	env["GITEA_PATH"] = env["GITHUB_PATH"]
-
-	return rc.JobContainer.Copy(actPath,
-		&container.FileEntry{Name: hookEnvFileCommand, Mode: 0o666},
-		&container.FileEntry{Name: hookPathFileCommand, Mode: 0o666},
-	)(ctx)
-}
-
-func (rc *RunContext) processHookFileCommands(ctx context.Context) error {
-	if err := processRunnerEnvFileCommand(ctx, hookEnvFileCommand, rc, rc.setEnv); err != nil {
-		return err
-	}
-	return rc.UpdateExtraPath(ctx, path.Join(rc.JobContainer.GetActPath(), hookPathFileCommand))
-}
-
-// hookCommand mirrors actions/runner, which deliberately does not apply the shell flags it
-// gives `run:` steps — a hook sets its own. See docs/adrs/1751-runner-job-hooks.md there.
-// The second return value is how the invocation is shown in the log, empty when the file is
-// executed directly.
-func hookCommand(hookPath string) (cmd []string, shell string) {
-	switch strings.ToLower(path.Ext(hookPath)) {
-	case ".sh":
-		return []string{"bash", "-e", hookPath}, "bash -e {0}"
-	case ".ps1":
-		return []string{"pwsh", "-command", ". '" + hookPath + "'"}, `pwsh -command ". '{0}'"`
-	default:
-		return []string{hookPath}, ""
-	}
-}

act/runner/job_hooks_test.go

@@ -1,162 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package runner
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"maps"
-	"testing"
-
-	"gitea.com/gitea/runner/act/common"
-	"gitea.com/gitea/runner/act/model"
-
-	"github.com/sirupsen/logrus/hooks/test"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hookContainer records the command a hook was run with and answers with what the hook
-// wrote to its GITHUB_ENV and GITHUB_PATH files.
-type hookContainer struct {
-	fakeContainer
-	cmd     []string
-	env     map[string]string
-	err     error
-	envFile map[string]string
-	pathTar []byte
-}
-
-func (c *hookContainer) ToContainerPath(path string) string { return path }
-func (c *hookContainer) IsEnvironmentCaseInsensitive() bool { return false }
-
-func (c *hookContainer) GetRunnerContext(context.Context) map[string]any {
-	return map[string]any{"os": "Linux"}
-}
-
-func (c *hookContainer) Exec(command []string, env map[string]string, _, _ string) common.Executor {
-	return func(context.Context) error {
-		c.cmd, c.env = command, env
-		return c.err
-	}
-}
-
-func (c *hookContainer) UpdateFromEnv(_ string, env *map[string]string) common.Executor {
-	return func(context.Context) error {
-		maps.Copy(*env, c.envFile)
-		return nil
-	}
-}
-
-func (c *hookContainer) GetContainerArchive(context.Context, string) (io.ReadCloser, error) {
-	return io.NopCloser(bytes.NewReader(c.pathTar)), nil
-}
-
-// newHookRunContext returns a RunContext and the context to run a hook with, whose logger is
-// silenced so the hook's job-log output does not reach the test output.
-func newHookRunContext(jobContainer *hookContainer, config *Config) (*RunContext, context.Context) {
-	// Env is left nil so that it is built from the config, as it is for a real job.
-	rc := &RunContext{
-		Config:       config,
-		Run:          &model.Run{JobID: "job", Workflow: &model.Workflow{Jobs: map[string]*model.Job{"job": {}}}},
-		JobContainer: jobContainer,
-	}
-	logger, _ := test.NewNullLogger()
-	ctx := common.WithJobErrorContainer(common.WithLogger(context.Background(), logger.WithField("test", true)))
-	rc.ExprEval = rc.NewExpressionEvaluator(ctx)
-	return rc, ctx
-}
-
-func TestRunJobHook(t *testing.T) {
-	t.Run("runs the hook with the job environment", func(t *testing.T) {
-		jobContainer := &hookContainer{}
-		rc, ctx := newHookRunContext(jobContainer, &Config{
-			JobStartedHook: "/hooks/started.sh",
-			Env:            map[string]string{"A_VAR": "value", jobStartedHookEnv: "/from/env.sh"},
-		})
-
-		require.NoError(t, rc.runJobStartedHook(ctx))
-
-		// The setting wins over the environment variable.
-		assert.Equal(t, []string{"bash", "-e", "/hooks/started.sh"}, jobContainer.cmd)
-		assert.Equal(t, "value", jobContainer.env["A_VAR"])
-		// The github environment is there too, so a hook can tell which job it runs for.
-		assert.Equal(t, "job", jobContainer.env["GITHUB_JOB"])
-		assert.Equal(t, "/var/run/act/workflow/hook-envs.txt", jobContainer.env["GITHUB_ENV"])
-		assert.Equal(t, "/var/run/act/workflow/hook-path.txt", jobContainer.env["GITHUB_PATH"])
-	})
-
-	// Each hook reads its own variable, so a swapped constant cannot pass.
-	t.Run("falls back to the GitHub environment variables", func(t *testing.T) {
-		for name, hook := range map[string]struct {
-			env string
-			run func(*RunContext, context.Context) error
-		}{
-			"started":   {jobStartedHookEnv, (*RunContext).runJobStartedHook},
-			"completed": {jobCompletedHookEnv, (*RunContext).runJobCompletedHook},
-		} {
-			t.Run(name, func(t *testing.T) {
-				jobContainer := &hookContainer{}
-				rc, ctx := newHookRunContext(jobContainer, &Config{Env: map[string]string{hook.env: "/from/env.sh"}})
-
-				require.NoError(t, hook.run(rc, ctx))
-				assert.Equal(t, []string{"bash", "-e", "/from/env.sh"}, jobContainer.cmd)
-			})
-		}
-	})
-
-	t.Run("exports what the hook wrote to GITHUB_ENV and GITHUB_PATH", func(t *testing.T) {
-		jobContainer := &hookContainer{
-			envFile: map[string]string{"FROM_HOOK": "1"},
-			pathTar: tarArchive(t, tarEntry{name: "hook-path.txt", body: "/opt/tool/bin\n"}),
-		}
-		rc, ctx := newHookRunContext(jobContainer, &Config{JobStartedHook: "/hooks/started.sh"})
-
-		require.NoError(t, rc.runJobStartedHook(ctx))
-
-		assert.Equal(t, "1", rc.Env["FROM_HOOK"])
-		assert.Equal(t, []string{"/opt/tool/bin"}, rc.ExtraPath)
-	})
-
-	t.Run("a failing hook fails the job", func(t *testing.T) {
-		rc, ctx := newHookRunContext(&hookContainer{err: errors.New("boom")}, &Config{JobStartedHook: "/hooks/started.sh"})
-
-		err := rc.runJobStartedHook(ctx)
-
-		require.ErrorContains(t, err, `the job started hook "/hooks/started.sh" failed`)
-		require.ErrorContains(t, err, "boom")
-		// The failure has to flip the job status, or success()-default steps would still
-		// run and the task would be reported successful despite the missing setup.
-		assert.Equal(t, "failure", rc.getJobContext().Status)
-		require.ErrorContains(t, common.JobError(ctx), "boom")
-	})
-
-	t.Run("is a no-op without a hook", func(t *testing.T) {
-		jobContainer := &hookContainer{}
-		rc, ctx := newHookRunContext(jobContainer, &Config{})
-
-		require.NoError(t, rc.runJobStartedHook(ctx))
-		require.NoError(t, rc.runJobCompletedHook(ctx))
-		assert.Nil(t, jobContainer.cmd)
-	})
-}
-
-// actions/runner deliberately runs a hook without the flags it gives `run:` steps, and an
-// executable without a known extension speaks for itself through its shebang.
-func TestHookCommand(t *testing.T) {
-	for hookPath, want := range map[string]struct {
-		cmd   []string
-		shell string
-	}{
-		"/hooks/started.sh":  {[]string{"bash", "-e", "/hooks/started.sh"}, "bash -e {0}"},
-		"/hooks/started.PS1": {[]string{"pwsh", "-command", ". '/hooks/started.PS1'"}, `pwsh -command ". '{0}'"`},
-		"/hooks/started":     {[]string{"/hooks/started"}, ""},
-	} {
-		cmd, shell := hookCommand(hookPath)
-		assert.Equal(t, want.cmd, cmd, hookPath)
-		assert.Equal(t, want.shell, shell, hookPath)
-	}
-}

act/runner/logger.go

@@ -175,10 +175,6 @@ func AppendSecretMasker(oldnew []string, v string) []string {
 		// formatted JSON secrets could otherwise mask {,[,],} everywhere
 		if len(tm) > 1 {
 			ret = append(ret, tm, "***")
-			// command data reaches the log escaped, so "pass%word" also arrives as "pass%25word"
-			if strings.ContainsAny(tm, "%\r\n") {
-				ret = append(ret, escapeCommandData(tm), "***")
-			}
 		}
 	}
 
@@ -234,11 +230,6 @@ type jobLogFormatter struct {
 func (f *jobLogFormatter) Format(entry *logrus.Entry) ([]byte, error) {
 	b := &bytes.Buffer{}
 
-	// the web renderer decodes command data, so this local view has to as well
-	if _, _, _, ok := tryParseRawActionCommand(entry.Message + "\n"); ok {
-		entry.Message = UnescapeCommandData(entry.Message)
-	}
-
 	if f.isColored(entry) {
 		f.printColored(b, entry)
 	} else {

act/runner/logger_test.go

@@ -4,13 +4,11 @@
 package runner
 
 import (
-	"io"
 	"strings"
 	"testing"
 
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestValueMasker(t *testing.T) {
@@ -35,12 +33,6 @@ func TestValueMasker(t *testing.T) {
 			masks:      []string{"PRIVATE_KEY_BEGIN\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\ndsdfseffefsefes\nPRIVATE_KEY_END"},
 			disallowed: []string{"KEY", "dsdfseffefsefes", "PRIVATE_KEY_END"},
 		},
-		{
-			name:       "Secret containing a percent sign",
-			lines:      "##[error]login failed for pass%25word",
-			secrets:    map[string]string{"TOKEN": "pass%word"},
-			disallowed: []string{"pass%25word"},
-		},
 	}
 	for _, entry := range table {
 		t.Run(entry.name, func(t *testing.T) {
@@ -58,17 +50,3 @@ func TestValueMasker(t *testing.T) {
 		})
 	}
 }
-
-func TestJobLogFormatterDecodesCommandData(t *testing.T) {
-	logger := logrus.New()
-	logger.Out = io.Discard
-	format := func(message string) string {
-		out, err := (&jobLogFormatter{}).Format(&logrus.Entry{Logger: logger, Message: message, Data: logrus.Fields{rawOutputField: true}})
-		require.NoError(t, err)
-		return string(out)
-	}
-
-	assert.Contains(t, format("##[error]deploy 50%25 traffic"), "##[error]deploy 50% traffic")
-	// a plain line is not command data and keeps its literal escapes
-	assert.Contains(t, format("progress 50%25 done"), "progress 50%25 done")
-}

act/runner/run_context.go

@@ -22,17 +22,15 @@ import (
 	"runtime"
 	"slices"
 	"strings"
+	"sync"
 	"time"
 
 	"gitea.com/gitea/runner/act/common"
 	"gitea.com/gitea/runner/act/container"
 	"gitea.com/gitea/runner/act/exprparser"
 	"gitea.com/gitea/runner/act/model"
-	"gitea.com/gitea/runner/internal/pkg/lock"
 
-	"github.com/docker/cli/cli/compose/loader"
 	"github.com/docker/go-connections/nat"
-	"github.com/moby/moby/api/types/mount"
 	"github.com/opencontainers/selinux/go-selinux"
 )
 
@@ -140,9 +138,7 @@ func (rc *RunContext) GetEnv() map[string]string {
 			}
 		}
 	}
-	if !rc.Config.DisableActEnv {
+	rc.Env["ACT"] = "true"
-		rc.Env["ACT"] = "true"
-	}
 
 	if !rc.Config.NoSkipCheckout {
 		rc.Env["ACT_SKIP_CHECKOUT"] = "true"
@@ -206,93 +202,52 @@ func (rc *RunContext) validVolumes() []string {
 		getDockerDaemonSocketMountPath(rc.containerDaemonSocket()))
 }
 
-// toolCache returns the tool cache path the job sees, relocatable through RUNNER_TOOL_CACHE.
-func (rc *RunContext) toolCache(fallback string) string {
-	if path := rc.GetEnv()["RUNNER_TOOL_CACHE"]; path != "" {
-		return path
-	}
-	return fallback
-}
-
-// runnerEnv returns a container's RUNNER_* variables, derived from the values runner.tool_cache
-// and friends report so the two cannot drift apart.
-func (rc *RunContext) runnerEnv(ctx context.Context) []string {
-	ext := container.LinuxContainerEnvironmentExtensions{}
-	runnerContext := ext.GetRunnerContext(ctx)
-	runnerContext["tool_cache"] = rc.toolCache(container.DefaultToolCache)
-
-	env := make([]string, 0, len(runnerContext))
-	for key, value := range runnerContext {
-		env = append(env, fmt.Sprintf("RUNNER_%s=%s", strings.ToUpper(key), value))
-	}
-	slices.Sort(env)
-	return env
-}
-
-// splitVolumes routes volume specs into binds and a source:target mount map, and returns the
-// container paths they mount onto. Only a plain source:target volume fits the map, everything
-// else (anonymous volumes, host binds, mount options) stays a bind.
-func splitVolumes(specs []string) ([]string, map[string]string, map[string]bool) {
-	binds := []string{}
-	mounts := map[string]string{}
-	targets := map[string]bool{}
-
-	for _, spec := range specs {
-		parsed, err := loader.ParseVolume(spec)
-		if err != nil {
-			binds = append(binds, spec) // let Docker report the malformed spec
-			continue
-		}
-		targets[parsed.Target] = true
-		if parsed.Type == string(mount.TypeVolume) && parsed.Source != "" && !parsed.ReadOnly {
-			mounts[parsed.Source] = parsed.Target
-		} else {
-			binds = append(binds, spec)
-		}
-	}
-	return binds, mounts, targets
-}
-
 // Returns the binds and mounts for the container, resolving paths as appopriate
 func (rc *RunContext) GetBindsAndMounts() ([]string, map[string]string) {
 	name := rc.jobContainerName()
+
+	binds := []string{}
+	if daemonSocket := rc.containerDaemonSocket(); daemonSocket != "-" {
+		daemonPath := getDockerDaemonSocketMountPath(daemonSocket)
+		binds = append(binds, fmt.Sprintf("%s:%s", daemonPath, "/var/run/docker.sock"))
+	}
+
 	ext := container.LinuxContainerEnvironmentExtensions{}
 
-	var volumes []string
+	mounts := map[string]string{
+		"act-toolcache": "/opt/hostedtoolcache",
+		name + "-env":   ext.GetActPath(),
+	}
+
 	if job := rc.Run.Job(); job != nil {
 		if container := job.Container(); container != nil {
 			for _, v := range container.Volumes {
 				if rc.ExprEval != nil {
 					v = rc.ExprEval.Interpolate(context.Background(), v)
 				}
-				volumes = append(volumes, v)
+				if !strings.Contains(v, ":") || filepath.IsAbs(v) {
+					// Bind anonymous volume or host file.
+					binds = append(binds, v)
+				} else {
+					// Mount existing volume.
+					paths := strings.SplitN(v, ":", 2)
+					mounts[paths[0]] = paths[1]
+				}
 			}
 		}
 	}
-	// the runner's own mounts below yield to the targets the job claims
-	binds, mounts, claimed := splitVolumes(volumes)
 
-	if daemonSocket := rc.containerDaemonSocket(); daemonSocket != "-" && !claimed["/var/run/docker.sock"] {
+	if rc.Config.BindWorkdir {
-		binds = append(binds, getDockerDaemonSocketMountPath(daemonSocket)+":/var/run/docker.sock")
+		bindModifiers := ""
-	}
+		if runtime.GOOS == "darwin" {
-	if toolCache := rc.toolCache(container.DefaultToolCache); !claimed[toolCache] {
+			bindModifiers = ":delegated"
-		mounts["act-toolcache"] = toolCache
-	}
-	mounts[name+"-env"] = ext.GetActPath() // runner-internal, never overridable
-
-	if workdir := ext.ToContainerPath(rc.Config.Workdir); !claimed[workdir] {
-		if rc.Config.BindWorkdir {
-			bindModifiers := ""
-			if runtime.GOOS == "darwin" {
-				bindModifiers = ":delegated"
-			}
-			if selinux.GetEnabled() {
-				bindModifiers = ":z"
-			}
-			binds = append(binds, fmt.Sprintf("%s:%s%s", rc.Config.Workdir, workdir, bindModifiers))
-		} else {
-			mounts[name] = workdir
 		}
+		if selinux.GetEnabled() {
+			bindModifiers = ":z"
+		}
+		binds = append(binds, fmt.Sprintf("%s:%s%s", rc.Config.Workdir, ext.ToContainerPath(rc.Config.Workdir), bindModifiers))
+	} else {
+		mounts[name] = ext.ToContainerPath(rc.Config.Workdir)
 	}
 
 	return binds, mounts
@@ -326,10 +281,7 @@ func (rc *RunContext) startHostEnvironment() common.Executor {
 		if err := os.MkdirAll(runnerTmp, 0o777); err != nil {
 			return err
 		}
-		toolCache := rc.toolCache(filepath.Join(cacheDir, "tool_cache"))
+		toolCache := filepath.Join(cacheDir, "tool_cache")
-		if err := os.MkdirAll(toolCache, 0o777); err != nil {
-			return err
-		}
 		rc.JobContainer = &container.HostEnvironment{
 			Path:         path,
 			TmpDir:       runnerTmp,
@@ -344,7 +296,7 @@ func (rc *RunContext) startHostEnvironment() common.Executor {
 			AllocatePTY: rc.Config.AllocatePTY,
 		}
 		rc.cleanUpJobContainer = rc.JobContainer.Remove()
-		for k, v := range rc.getRunnerContext(ctx) {
+		for k, v := range rc.JobContainer.GetRunnerContext(ctx) {
 			if v, ok := v.(string); ok {
 				rc.Env["RUNNER_"+strings.ToUpper(k)] = v
 			}
@@ -385,9 +337,6 @@ func printStartJobContainerGroup(ctx context.Context, image, name, network strin
 	}
 }
 
-// newContainer is a variable so tests can substitute a container that needs no Docker daemon.
-var newContainer = container.NewContainer
-
 func (rc *RunContext) startJobContainer() common.Executor {
 	return func(ctx context.Context) error {
 		logger := common.Logger(ctx)
@@ -414,7 +363,10 @@ func (rc *RunContext) startJobContainer() common.Executor {
 
 		envList := make([]string, 0)
 
-		envList = append(envList, rc.runnerEnv(ctx)...)
+		envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TOOL_CACHE", "/opt/hostedtoolcache"))
+		envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_OS", "Linux"))
+		envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_ARCH", container.RunnerArch(ctx)))
+		envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TEMP", "/tmp"))
 		envList = append(envList, fmt.Sprintf("%s=%s", "LANG", "C.UTF-8")) // Use same locale as GitHub Actions
 
 		ext := container.LinuxContainerEnvironmentExtensions{}
@@ -427,17 +379,8 @@ func (rc *RunContext) startJobContainer() common.Executor {
 
 		// add service containers
 		for serviceID, spec := range rc.Run.Job().Services {
-			// GitHub compatibility: skip services whose image evaluates to an
-			// empty string, enabling conditional services via expressions
-			serviceImage := rc.ExprEval.Interpolate(ctx, spec.Image)
-			if serviceImage == "" {
-				logger.Infof("The service '%s' will not be started because the container definition has an empty image.", serviceID)
-				continue
-			}
 			// interpolate env
-			interpolatedEnvs := make(map[string]string, len(spec.Env)+len(rc.Config.ProxyEnv))
+			interpolatedEnvs := make(map[string]string, len(spec.Env))
-			// a service reaches the internet the way the job does; its own env still wins
-			maps0.Copy(interpolatedEnvs, rc.Config.ProxyEnv)
 			for k, v := range spec.Env {
 				interpolatedEnvs[k] = rc.ExprEval.Interpolate(ctx, v)
 			}
@@ -450,9 +393,7 @@ func (rc *RunContext) startJobContainer() common.Executor {
 			for _, v := range spec.Cmd {
 				interpolatedCmd = append(interpolatedCmd, rc.ExprEval.Interpolate(ctx, v))
 			}
-			// keep these local: reusing username/password would overwrite the
+			username, password, err = rc.handleServiceCredentials(ctx, spec.Credentials)
-			// credentials the job container is pulled with further down
-			serviceUsername, servicePassword, err := rc.handleServiceCredentials(ctx, spec.Credentials)
 			if err != nil {
 				return fmt.Errorf("failed to handle service %s credentials: %w", serviceID, err)
 			}
@@ -473,12 +414,12 @@ func (rc *RunContext) startJobContainer() common.Executor {
 			}
 
 			serviceContainerName := createContainerName(rc.jobContainerName(), serviceID)
-			c := newContainer(&container.NewContainerInput{
+			c := container.NewContainer(&container.NewContainerInput{
 				Name:           serviceContainerName,
 				WorkingDir:     ext.ToContainerPath(rc.Config.Workdir),
-				Image:          serviceImage,
+				Image:          rc.ExprEval.Interpolate(ctx, spec.Image),
-				Username:       serviceUsername,
+				Username:       username,
-				Password:       servicePassword,
+				Password:       password,
 				Cmd:            interpolatedCmd,
 				Env:            envs,
 				Mounts:         serviceMounts,
@@ -499,12 +440,42 @@ func (rc *RunContext) startJobContainer() common.Executor {
 			rc.ServiceContainers = append(rc.ServiceContainers, c)
 		}
 
-		rc.cleanUpJobContainer = rc.cleanupJobResources(networkName, createAndDeleteNetwork)
+		rc.cleanUpJobContainer = func(ctx context.Context) error {
+			reuseJobContainer := func(ctx context.Context) bool {
+				return rc.Config.ReuseContainers
+			}
+
+			if rc.JobContainer != nil {
+				return rc.JobContainer.Remove().IfNot(reuseJobContainer).
+					Then(container.NewDockerVolumeRemoveExecutor(rc.jobContainerName(), false)).IfNot(reuseJobContainer).
+					Then(container.NewDockerVolumeRemoveExecutor(rc.jobContainerName()+"-env", false)).IfNot(reuseJobContainer).
+					Then(func(ctx context.Context) error {
+						if len(rc.ServiceContainers) > 0 {
+							logger.Infof("Cleaning up services for job %s", rc.JobName)
+							if err := rc.stopServiceContainers()(ctx); err != nil {
+								logger.Errorf("Error while cleaning services: %v", err)
+							}
+						}
+						if createAndDeleteNetwork {
+							// clean network if it has been created by act
+							// if using service containers
+							// it means that the network to which containers are connecting is created by `runner`,
+							// so, we should remove the network at last.
+							logger.Infof("Cleaning up network for job %s, and network name is: %s", rc.JobName, networkName)
+							if err := container.NewDockerNetworkRemoveExecutor(networkName)(ctx); err != nil {
+								logger.Errorf("Error while cleaning network: %v", err)
+							}
+						}
+						return nil
+					})(ctx)
+			}
+			return nil
+		}
 
 		// For Gitea, `jobContainerNetwork` should be the same as `networkName`
 		jobContainerNetwork := networkName
 
-		rc.JobContainer = newContainer(&container.NewContainerInput{
+		rc.JobContainer = container.NewContainer(&container.NewContainerInput{
 			Cmd:            nil,
 			Entrypoint:     []string{"/bin/sleep", fmt.Sprint(rc.Config.ContainerMaxLifetime.Round(time.Second).Seconds())},
 			WorkingDir:     ext.ToContainerPath(rc.Config.Workdir),
@@ -554,41 +525,6 @@ func (rc *RunContext) startJobContainer() common.Executor {
 	}
 }
 
-// cleanupJobResources removes everything the job created, continuing past failures.
-// Only job container and volume errors are returned, the rest are logged.
-func (rc *RunContext) cleanupJobResources(networkName string, createAndDeleteNetwork bool) common.Executor {
-	return func(ctx context.Context) error {
-		logger := common.Logger(ctx)
-		removeJobContainer := rc.JobContainer != nil && !rc.Config.ReuseContainers
-
-		var errs []error
-		if removeJobContainer {
-			errs = append(errs, rc.JobContainer.Remove()(ctx))
-		}
-		if len(rc.ServiceContainers) > 0 {
-			logger.Infof("Cleaning up services for job %s", rc.JobName)
-			if err := rc.stopServiceContainers()(ctx); err != nil {
-				logger.Errorf("Error while cleaning services: %v", err)
-			}
-		}
-		if removeJobContainer {
-			// after the containers using them, services can hold these via `--volumes-from`
-			name := rc.jobContainerName()
-			errs = append(errs,
-				container.NewDockerVolumeRemoveExecutor(name, false)(ctx),
-				container.NewDockerVolumeRemoveExecutor(name+"-env", false)(ctx))
-		}
-		if createAndDeleteNetwork {
-			// last, once every container has detached
-			logger.Infof("Cleaning up network for job %s, and network name is: %s", rc.JobName, networkName)
-			if err := container.NewDockerNetworkRemoveExecutor(networkName)(ctx); err != nil {
-				logger.Errorf("Error while cleaning network: %v", err)
-			}
-		}
-		return errors.Join(errs...)
-	}
-}
-
 func (rc *RunContext) execJobContainer(cmd []string, env map[string]string, user, workdir string) common.Executor { //nolint:unparam // pre-existing issue from nektos/act
 	return func(ctx context.Context) error {
 		return rc.JobContainer.Exec(cmd, env, user, workdir)(ctx)
@@ -717,10 +653,13 @@ func (rc *RunContext) ActionCacheDir() string {
 // jobMutexes serializes per-job result/output aggregation across the matrix combinations that
 // share one *model.Job and run in parallel. Keyed by the shared *model.Job (mirrors the
 // per-directory AcquireCloneLock pattern).
-var jobMutexes lock.Keyed[*model.Job]
+var jobMutexes sync.Map // key: *model.Job; value: *sync.Mutex
 
 func lockJob(job *model.Job) func() {
-	return jobMutexes.Lock(job)
+	v, _ := jobMutexes.LoadOrStore(job, &sync.Mutex{})
+	mu := v.(*sync.Mutex)
+	mu.Lock()
+	return mu.Unlock
 }
 
 func (rc *RunContext) interpolateOutputs() common.Executor {
@@ -844,13 +783,7 @@ func (rc *RunContext) Executor() (common.Executor, error) {
 	return func(ctx context.Context) error {
 		res, err := rc.isEnabled(ctx)
 		if err != nil {
-			// Record the failure so a job whose if-expression fails to evaluate
+			rc.caller.setReusedWorkflowJobResult(rc.JobName, "failure") // For Gitea
-			// gets a result (and therefore a stop time) instead of being left
-			// unfinished. rc.caller is only set for reusable workflows.
-			rc.result("failure")
-			if rc.caller != nil { // For Gitea
-				rc.caller.setReusedWorkflowJobResult(rc.JobName, "failure")
-			}
 			return err
 		}
 		if res {
@@ -971,20 +904,6 @@ func (rc *RunContext) isEnabled(ctx context.Context) (bool, error) {
 	return true, nil
 }
 
-// proxyBuildArgs returns the job's proxy variables as docker build args. The docker CLI
-// pre-populates these from its own client configuration, but act builds through the API,
-// so without them a Dockerfile action's RUN steps have no network behind a proxy.
-func (rc *RunContext) proxyBuildArgs() map[string]*string {
-	if len(rc.Config.ProxyEnv) == 0 {
-		return nil
-	}
-	args := make(map[string]*string, len(rc.Config.ProxyEnv))
-	for name, value := range rc.Config.ProxyEnv {
-		args[name] = &value
-	}
-	return args
-}
-
 func mergeMaps(maps ...map[string]string) map[string]string {
 	rtnMap := make(map[string]string)
 	for _, m := range maps {
@@ -1042,23 +961,6 @@ func (rc *RunContext) getStepsContext() map[string]*model.StepResult {
 	return rc.StepResults
 }
 
-// getRunnerContext returns the `runner` context: what the execution environment knows
-// (os, arch, temp, tool_cache) plus what only the runner process knows.
-func (rc *RunContext) getRunnerContext(ctx context.Context) map[string]any {
-	runnerContext := map[string]any{}
-	if rc.JobContainer != nil {
-		maps0.Copy(runnerContext, rc.JobContainer.GetRunnerContext(ctx))
-		defaultToolCache, _ := runnerContext["tool_cache"].(string)
-		runnerContext["tool_cache"] = rc.toolCache(defaultToolCache)
-	}
-	runnerContext["name"] = rc.Config.RunnerName
-	runnerContext["environment"] = "self-hosted"
-	if rc.Config.RunnerDebug() {
-		runnerContext["debug"] = "1"
-	}
-	return runnerContext
-}
-
 func (rc *RunContext) getGithubContext(ctx context.Context) *model.GithubContext {
 	logger := common.Logger(ctx)
 	ghc := &model.GithubContext{
@@ -1243,7 +1145,7 @@ func nestedMapLookup(m map[string]any, ks ...string) (rval any) {
 	}
 }
 
-func (rc *RunContext) withGithubEnv(ctx context.Context, github *model.GithubContext, env map[string]string) {
+func (rc *RunContext) withGithubEnv(ctx context.Context, github *model.GithubContext, env map[string]string) map[string]string { //nolint:unparam // pre-existing issue from nektos/act
 	env["CI"] = "true"
 	env["GITHUB_WORKFLOW"] = github.Workflow
 	env["GITHUB_RUN_ID"] = github.RunID
@@ -1285,71 +1187,23 @@ func (rc *RunContext) withGithubEnv(ctx context.Context, github *model.GithubCon
 		env["GITHUB_RUN_ATTEMPT"] = github.RunAttempt
 	}
 
-	env["RUNNER_NAME"] = rc.Config.RunnerName
-	env["RUNNER_ENVIRONMENT"] = "self-hosted"
-	if workspace := parentDir(github.Workspace); workspace != "" {
-		env["RUNNER_WORKSPACE"] = workspace
-	}
-	if rc.Config.RunnerDebug() {
-		env["RUNNER_DEBUG"] = "1"
-	}
-
 	if rc.Config.ArtifactServerPath != "" {
 		setActionRuntimeVars(rc, env)
 	}
 
-	if imageOS := rc.imageOS(ctx); imageOS != "" {
+	for _, platformName := range rc.runsOnPlatformNames(ctx) {
-		env["ImageOS"] = imageOS
+		if platformName != "" {
-	}
+			if platformName == "ubuntu-latest" {
-}
+				// hardcode current ubuntu-latest since we have no way to check that 'on the fly'
-
+				env["ImageOS"] = "ubuntu20"
-// parentDir returns the directory containing p, or "" when p names no parent. Both
+			} else {
-// separators are accepted rather than filepath's, as p may describe a container while
+				platformName = strings.SplitN(strings.Replace(platformName, `-`, ``, 1), `.`, 2)[0]
-// the runner itself runs on Windows, or the other way round.
+				env["ImageOS"] = platformName
-func parentDir(p string) string {
+			}
-	if slash := strings.LastIndexAny(p, `/\`); slash > 0 {
-		return p[:slash]
-	}
-	return ""
-}
-
-// imageOS returns ImageOS, which setup-* actions use to tell one runner image release
-// from another. The resolved image tag is preferred over the runs-on label because it
-// still names a release when the label is a rolling one such as ubuntu-latest.
-func (rc *RunContext) imageOS(ctx context.Context) string {
-	if rc.Run.Job().RunsOn() == nil {
-		// A composite action runs on a synthetic job, and resolving its image would only
-		// log that runs-on is missing.
-		return ""
-	}
-	if imageOS := imageOSFromImage(rc.platformImage(ctx)); imageOS != "" {
-		return imageOS
-	}
-
-	for _, platformName := range slices.Backward(rc.runsOnPlatformNames(ctx)) {
-		if platformName == "ubuntu-latest" {
-			// Rolling label whose image names no release either, so keep the historical value.
-			return "ubuntu20"
-		} else if platformName != "" {
-			return strings.SplitN(strings.Replace(platformName, `-`, ``, 1), `.`, 2)[0]
 		}
 	}
-	return ""
-}
 
-// imageOSTag matches an image reference tagged with an OS family ImageOS can report plus
+	return env
-// its release, such as "docker.gitea.com/runner-images:ubuntu-24.04". Anything else
-// ("ubuntu-latest", "app:22.04", "catthehacker/ubuntu:act-22.04", or a registry port) is
-// left to the runs-on label rather than turned into a bogus OS.
-var imageOSTag = regexp.MustCompile(`:(ubuntu|win|macos)-?([0-9]+)[^/]*$`)
-
-// imageOSFromImage derives ImageOS from an image reference, e.g.
-// "docker.gitea.com/runner-images:ubuntu-24.04" yields "ubuntu24".
-func imageOSFromImage(image string) string {
-	if match := imageOSTag.FindStringSubmatch(image); match != nil {
-		return match[1] + match[2]
-	}
-	return ""
 }
 
 func setActionRuntimeVars(rc *RunContext, env map[string]string) {
@@ -1421,9 +1275,24 @@ func (rc *RunContext) handleServiceCredentials(ctx context.Context, creds map[st
 
 // GetServiceBindsAndMounts returns the binds and mounts for the service container, resolving paths as appopriate
 func (rc *RunContext) GetServiceBindsAndMounts(svcVolumes []string) ([]string, map[string]string) {
-	binds, mounts, claimed := splitVolumes(svcVolumes)
+	binds := []string{}
-	if daemonSocket := rc.containerDaemonSocket(); daemonSocket != "-" && !claimed["/var/run/docker.sock"] {
+	if daemonSocket := rc.containerDaemonSocket(); daemonSocket != "-" {
-		binds = append(binds, getDockerDaemonSocketMountPath(daemonSocket)+":/var/run/docker.sock")
+		daemonPath := getDockerDaemonSocketMountPath(daemonSocket)
+		binds = append(binds, fmt.Sprintf("%s:%s", daemonPath, "/var/run/docker.sock"))
 	}
+
+	mounts := map[string]string{}
+
+	for _, v := range svcVolumes {
+		if !strings.Contains(v, ":") || filepath.IsAbs(v) {
+			// Bind anonymous volume or host file.
+			binds = append(binds, v)
+		} else {
+			// Mount existing volume.
+			paths := strings.SplitN(v, ":", 2)
+			mounts[paths[0]] = paths[1]
+		}
+	}
+
 	return binds, mounts
 }

act/runner/run_context_test.go

@@ -7,7 +7,6 @@ package runner
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"os"
 	"runtime"
@@ -15,11 +14,9 @@ import (
 	"testing"
 
 	"gitea.com/gitea/runner/act/common"
-	"gitea.com/gitea/runner/act/container"
 	"gitea.com/gitea/runner/act/exprparser"
 	"gitea.com/gitea/runner/act/model"
 
-	"github.com/docker/cli/cli/compose/loader"
 	log "github.com/sirupsen/logrus"
 	assert "github.com/stretchr/testify/assert"
 	require "github.com/stretchr/testify/require"
@@ -205,170 +202,6 @@ jobs:
 	assert.Empty(t, password)
 }
 
-// fakeContainer turns every container operation into a no-op, so startJobContainer
-// runs without a Docker daemon. The embedded interface is nil, so any method the
-// test does not exercise panics rather than silently doing the wrong thing.
-type fakeContainer struct {
-	container.ExecutionsEnvironment
-}
-
-func (fakeContainer) Pull(bool) common.Executor  { return func(context.Context) error { return nil } }
-func (fakeContainer) Start(bool) common.Executor { return func(context.Context) error { return nil } }
-func (fakeContainer) Remove() common.Executor    { return func(context.Context) error { return nil } }
-func (fakeContainer) Close() common.Executor     { return func(context.Context) error { return nil } }
-func (fakeContainer) GetActPath() string         { return "/var/run/act" }
-func (fakeContainer) Create([]string, []string) common.Executor {
-	return func(context.Context) error { return nil }
-}
-
-func (fakeContainer) Copy(string, ...*container.FileEntry) common.Executor {
-	return func(context.Context) error { return nil }
-}
-
-// Regression test: a service without a `credentials:` block resolves to empty
-// credentials, which used to overwrite the job container's own credentials.
-func TestStartJobContainerKeepsJobCredentialsWithServices(t *testing.T) {
-	workflow, err := model.ReadWorkflow(strings.NewReader(`
-name: test
-on: push
-jobs:
-  job:
-    runs-on: ubuntu-latest
-    container:
-      image: registry.example/private:latest
-      credentials:
-        username: job-user
-        password: job-password
-    services:
-      redis:
-        image: redis:latest
-      db:
-        image: postgres:latest
-        credentials:
-          username: db-user
-          password: db-password
-    steps: []
-`))
-	require.NoError(t, err)
-
-	var inputs []*container.NewContainerInput
-	origNewContainer := newContainer
-	newContainer = func(input *container.NewContainerInput) container.ExecutionsEnvironment {
-		inputs = append(inputs, input)
-		return fakeContainer{}
-	}
-	t.Cleanup(func() { newContainer = origNewContainer })
-
-	rc := &RunContext{
-		Name: "test",
-		Config: &Config{
-			Workdir: "/tmp",
-			// no daemon: an explicit network mode creates no network, and
-			// reusing containers short-circuits the volume cleanup executors
-			ContainerNetworkMode: "host",
-			ReuseContainers:      true,
-			Env:                  map[string]string{},
-			Secrets:              map[string]string{},
-		},
-		Env: map[string]string{},
-		Run: &model.Run{
-			JobID:    "job",
-			Workflow: workflow,
-		},
-	}
-	rc.ExprEval = rc.NewExpressionEvaluator(t.Context())
-
-	require.NoError(t, rc.startJobContainer()(t.Context()))
-
-	credentials := map[string][2]string{}
-	for _, in := range inputs {
-		credentials[in.Image] = [2]string{in.Username, in.Password}
-	}
-
-	// the job container keeps its own credentials, whichever services exist
-	require.Equal(t, [2]string{"job-user", "job-password"}, credentials["registry.example/private:latest"])
-	// each service keeps its own, and a service without credentials gets none
-	require.Equal(t, [2]string{"db-user", "db-password"}, credentials["postgres:latest"])
-	require.Equal(t, [2]string{"", ""}, credentials["redis:latest"])
-}
-
-// A service container reaches the internet the same way the job does, so it inherits the
-// job's proxy; a service that sets the variable itself keeps its own value.
-func TestStartJobContainerGivesServicesTheJobProxy(t *testing.T) {
-	workflow, err := model.ReadWorkflow(strings.NewReader(`
-name: test
-on: push
-jobs:
-  job:
-    runs-on: ubuntu-latest
-    container:
-      image: registry.example/job:latest
-    services:
-      redis:
-        image: redis:latest
-      db:
-        image: postgres:latest
-        env:
-          no_proxy: db-only.example
-    steps: []
-`))
-	require.NoError(t, err)
-
-	var inputs []*container.NewContainerInput
-	origNewContainer := newContainer
-	newContainer = func(input *container.NewContainerInput) container.ExecutionsEnvironment {
-		inputs = append(inputs, input)
-		return fakeContainer{}
-	}
-	t.Cleanup(func() { newContainer = origNewContainer })
-
-	rc := &RunContext{
-		Name: "test",
-		Config: &Config{
-			Workdir:              "/tmp",
-			ContainerNetworkMode: "host",
-			ReuseContainers:      true,
-			Env:                  map[string]string{},
-			ProxyEnv:             map[string]string{"http_proxy": "http://proxy:3128", "no_proxy": "internal.example"},
-			Secrets:              map[string]string{},
-		},
-		Env: map[string]string{},
-		Run: &model.Run{
-			JobID:    "job",
-			Workflow: workflow,
-		},
-	}
-	rc.ExprEval = rc.NewExpressionEvaluator(t.Context())
-
-	require.NoError(t, rc.startJobContainer()(t.Context()))
-
-	env := map[string][]string{}
-	for _, in := range inputs {
-		env[in.Image] = in.Env
-	}
-
-	require.Contains(t, env["redis:latest"], "http_proxy=http://proxy:3128")
-	require.Contains(t, env["redis:latest"], "no_proxy=internal.example")
-	// the service's own env wins over what the runner injected, without dropping the rest
-	require.Contains(t, env["postgres:latest"], "no_proxy=db-only.example")
-	require.NotContains(t, env["postgres:latest"], "no_proxy=internal.example")
-	require.Contains(t, env["postgres:latest"], "http_proxy=http://proxy:3128")
-}
-
-// act builds Dockerfile actions through the API, which does not pre-populate the proxy
-// build args the docker CLI would, so the RUN steps would have no network behind a proxy.
-func TestProxyBuildArgs(t *testing.T) {
-	rc := &RunContext{Config: &Config{ProxyEnv: map[string]string{"http_proxy": "http://proxy:3128"}}}
-
-	args := rc.proxyBuildArgs()
-
-	require.Len(t, args, 1)
-	require.Equal(t, "http://proxy:3128", *args["http_proxy"])
-
-	// a job without a proxy builds exactly as it does today
-	require.Nil(t, (&RunContext{Config: &Config{}}).proxyBuildArgs())
-}
-
 func TestRunContext_GetBindsAndMounts(t *testing.T) {
 	rctemplate := &RunContext{
 		Name: "TestRCName",
@@ -441,10 +274,6 @@ func TestRunContext_GetBindsAndMounts(t *testing.T) {
 			{"BindAnonymousVolume", []string{"/volume"}, "/volume", map[string]string{}},
 			{"BindHostFile", []string{"/path/to/file/on/host:/volume"}, "/path/to/file/on/host:/volume", map[string]string{}},
 			{"MountExistingVolume", []string{"volume-id:/volume"}, "", map[string]string{"volume-id": "/volume"}},
-			{"MountExistingVolumeReadOnly", []string{"volume-id:/volume:ro"}, "volume-id:/volume:ro", map[string]string{}},
-			{"BindRelativeHostPath", []string{"./relative:/volume"}, "./relative:/volume", map[string]string{}},
-			{"OverridesToolCache", []string{"/host/tools:/opt/hostedtoolcache"}, "/host/tools:/opt/hostedtoolcache", map[string]string{}},
-			{"OverridesDockerSocket", []string{"/host/docker.sock:/var/run/docker.sock"}, "/host/docker.sock:/var/run/docker.sock", map[string]string{}},
 		}
 
 		t.Run("InterpolatedContainerVolumes", func(t *testing.T) {
@@ -500,37 +329,15 @@ func TestRunContext_GetBindsAndMounts(t *testing.T) {
 				rc.Run.JobID = "job1"
 				rc.Run.Workflow.Jobs = map[string]*model.Job{"job1": job}
 
-				jobBinds, jobMounts := rc.GetBindsAndMounts()
+				gotbind, gotmount := rc.GetBindsAndMounts()
-				svcBinds, svcMounts := rc.GetServiceBindsAndMounts(testcase.volumes)
-				// job and service containers classify volumes alike, only their own mounts differ
-				for _, got := range []struct {
-					binds  []string
-					mounts map[string]string
-				}{{jobBinds, jobMounts}, {svcBinds, svcMounts}} {
-					gotbind, gotmount := got.binds, got.mounts
 
-					if len(testcase.wantbind) > 0 {
+				if len(testcase.wantbind) > 0 {
-						assert.Contains(t, gotbind, testcase.wantbind)
+					assert.Contains(t, gotbind, testcase.wantbind)
-					}
+				}
 
-					for k, v := range testcase.wantmount {
+				for k, v := range testcase.wantmount {
-						assert.Contains(t, gotmount, k)
+					assert.Contains(t, gotmount, k)
-						assert.Equal(t, gotmount[k], v)
+					assert.Equal(t, gotmount[k], v)
-					}
-
-					// Docker rejects a container with two mounts on one target, so the job's own
-					// volumes must displace the runner's rather than pile up next to them.
-					targets := map[string]bool{}
-					for _, bind := range gotbind {
-						parsed, err := loader.ParseVolume(bind)
-						require.NoError(t, err)
-						assert.NotContains(t, targets, parsed.Target, "%s mounts an already mounted target", bind)
-						targets[parsed.Target] = true
-					}
-					for source, target := range gotmount {
-						assert.NotContains(t, targets, target, "%s mounts an already mounted target", source)
-						targets[target] = true
-					}
 				}
 			})
 		}
@@ -556,46 +363,6 @@ func TestRunContextValidVolumes(t *testing.T) {
 	assert.Len(t, rc.validVolumes(), len(got), "repeated calls must be stable, not accumulate")
 }
 
-func TestCleanupJobResourcesCleansServicesWithoutJobContainer(t *testing.T) {
-	service := &containerMock{}
-	service.On("Remove").Return(func(context.Context) error { return nil }).Once()
-	service.On("Close").Return(func(context.Context) error { return nil }).Once()
-
-	rc := &RunContext{
-		Config:            &Config{},
-		ServiceContainers: []container.ExecutionsEnvironment{service},
-	}
-
-	err := rc.cleanupJobResources("external-network", false)(context.Background())
-	require.NoError(t, err)
-	service.AssertExpectations(t)
-}
-
-// cleanup used to bail out on a previous step's error and on a cancelled context
-func TestCleanupJobResourcesContinuesAfterFailure(t *testing.T) {
-	t.Setenv("DOCKER_HOST", "unix:///nonexistent.sock")
-
-	jobContainer := &containerMock{}
-	jobContainer.On("Remove").Return(func(context.Context) error { return errors.New("removal failed") }).Once()
-	service := &containerMock{}
-	service.On("Remove").Return(func(context.Context) error { return nil }).Once()
-	service.On("Close").Return(func(context.Context) error { return nil }).Once()
-
-	rc := &RunContext{
-		Name:              "job",
-		Config:            &Config{},
-		Run:               &model.Run{Workflow: &model.Workflow{Name: "wf"}, JobID: "job"},
-		JobContainer:      jobContainer,
-		ServiceContainers: []container.ExecutionsEnvironment{service},
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	require.Error(t, rc.cleanupJobResources("job-network", true)(ctx))
-	jobContainer.AssertExpectations(t)
-	service.AssertExpectations(t)
-}
-
 // TestInterpolateOutputsIsPerMatrixCombo guards the matrix-output fix: combinations share one
 // *model.Job, so each must interpolate from its own pristine snapshot. Otherwise the first
 // combo's resolved value freezes the shared template and later combos can't resolve their own.
@@ -1044,117 +811,3 @@ func TestRunContext_cleanupFailedStart(t *testing.T) {
 		assert.NotPanics(t, func() { (&RunContext{}).cleanupFailedStart(context.Background()) })
 	})
 }
-
-func TestImageOSFromImage(t *testing.T) {
-	for _, tc := range []struct {
-		image string
-		want  string
-	}{
-		{"", ""},
-		{"docker.gitea.com/runner-images:ubuntu-24.04", "ubuntu24"},
-		{"docker.gitea.com/runner-images:ubuntu-latest", ""},
-		{"runner-images:ubuntu22.04", "ubuntu22"},
-		{"node:20", ""},
-		{"ubuntu:22.04", ""},
-		{"ubuntu", ""},
-		{"catthehacker/ubuntu:act-22.04", ""},
-		{"myco/ubuntu:v2.1", ""},
-		{"myco/ubuntu:v22.04", ""},
-		{"app:release-1", ""},
-		{"app:1.2.3", ""},
-		{"app:build-2.1", ""},
-		{"registry.example.com:5000/runner-images", ""},
-		{"registry.example.com:5000/runner-images:ubuntu-24.04", "ubuntu24"},
-	} {
-		t.Run(tc.image, func(t *testing.T) {
-			assert.Equal(t, tc.want, imageOSFromImage(tc.image))
-		})
-	}
-}
-
-func createRunsOnRunContext(t *testing.T, runsOn string) *RunContext {
-	return createIfTestRunContext(map[string]*model.Job{
-		"job1": createJob(t, "runs-on: "+runsOn, ""),
-	})
-}
-
-func TestRunContextImageOS(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("prefers the release in the resolved image tag", func(t *testing.T) {
-		rc := createRunsOnRunContext(t, "ubuntu-latest")
-		rc.Config.Platforms = map[string]string{
-			"ubuntu-latest": "docker.gitea.com/runner-images:ubuntu-24.04",
-		}
-		assert.Equal(t, "ubuntu24", rc.imageOS(ctx))
-	})
-
-	t.Run("falls back to the runs-on label", func(t *testing.T) {
-		rc := createRunsOnRunContext(t, "ubuntu-22.04")
-		rc.Config.Platforms = map[string]string{"ubuntu-22.04": "some-image"}
-		assert.Equal(t, "ubuntu22", rc.imageOS(ctx))
-	})
-
-	t.Run("keeps the historical value for a rolling label with no release", func(t *testing.T) {
-		assert.Equal(t, "ubuntu20", createRunsOnRunContext(t, "ubuntu-latest").imageOS(ctx))
-	})
-
-	t.Run("is empty for the synthetic job of a composite action", func(t *testing.T) {
-		rc := createIfTestRunContext(map[string]*model.Job{"job1": {}})
-		assert.Empty(t, rc.imageOS(ctx))
-	})
-}
-
-func TestRunContextGetRunnerContext(t *testing.T) {
-	ctx := context.Background()
-
-	t.Run("adds the runner values the container cannot know", func(t *testing.T) {
-		rc := createRunsOnRunContext(t, "ubuntu-latest")
-		rc.Config.RunnerName = "runner-1"
-
-		runnerContext := rc.getRunnerContext(ctx)
-		assert.Equal(t, "runner-1", runnerContext["name"])
-		assert.Equal(t, "self-hosted", runnerContext["environment"])
-		assert.NotContains(t, runnerContext, "debug")
-	})
-
-	t.Run("reports debug when step debugging is on", func(t *testing.T) {
-		rc := createRunsOnRunContext(t, "ubuntu-latest")
-		rc.Config.Secrets = map[string]string{"ACTIONS_STEP_DEBUG": "true"}
-
-		assert.Equal(t, "1", rc.getRunnerContext(ctx)["debug"])
-	})
-
-	t.Run("keeps the execution environment values", func(t *testing.T) {
-		rc := createRunsOnRunContext(t, "ubuntu-latest")
-		rc.JobContainer = &container.HostEnvironment{TmpDir: "/tmp/act", ToolCache: "/tmp/tool_cache"}
-
-		runnerContext := rc.getRunnerContext(ctx)
-		assert.Equal(t, "/tmp/act", runnerContext["temp"])
-		assert.Equal(t, "/tmp/tool_cache", runnerContext["tool_cache"])
-		assert.NotEmpty(t, runnerContext["os"])
-	})
-}
-
-func TestParentDir(t *testing.T) {
-	assert.Empty(t, parentDir(""))
-	assert.Empty(t, parentDir("repo"))
-	assert.Empty(t, parentDir("/repo"))
-	assert.Equal(t, "/workspace/owner", parentDir("/workspace/owner/repo"))
-	assert.Equal(t, `C:\workspace\owner`, parentDir(`C:\workspace\owner\repo`))
-}
-
-func TestRunContextWithGithubEnvRunnerValues(t *testing.T) {
-	ctx := context.Background()
-	rc := createRunsOnRunContext(t, "ubuntu-latest")
-	rc.Config.RunnerName = "runner-1"
-	rc.Config.Secrets = map[string]string{"ACTIONS_STEP_DEBUG": "true"}
-
-	env := map[string]string{}
-	rc.withGithubEnv(ctx, &model.GithubContext{Workspace: "/workspace/owner/repo"}, env)
-
-	assert.Equal(t, "runner-1", env["RUNNER_NAME"])
-	assert.Equal(t, "self-hosted", env["RUNNER_ENVIRONMENT"])
-	assert.Equal(t, "/workspace/owner", env["RUNNER_WORKSPACE"])
-	assert.Equal(t, "1", env["RUNNER_DEBUG"])
-}

act/runner/runner.go

@@ -65,7 +65,6 @@ type Config struct {
 	ArtifactServerAddr                 string                                        // the address the artifact server binds to
 	ArtifactServerPort                 string                                        // the port the artifact server binds to
 	NoSkipCheckout                     bool                                          // do not skip actions/checkout
-	DisableActEnv                      bool                                          // do not inject the ACT=true environment variable into jobs
 	RemoteName                         string                                        // remote name in local git repo config
 	ReplaceGheActionWithGithubCom      []string                                      // Use actions from GitHub Enterprise instance to GitHub
 	ReplaceGheActionTokenWithGithubCom string                                        // Token of private action repo on GitHub.
@@ -73,7 +72,6 @@ type Config struct {
 	ContainerNetworkMode               docker_container.NetworkMode                  // the network mode of job containers (the value of --network)
 	ContainerNetworkCreateOptions      container.NewDockerNetworkCreateExecutorInput // the default network create options
 	ActionCache                        ActionCache                                   // Use a custom ActionCache Implementation
-	ProxyEnv                           map[string]string                             // the proxy variables the job runs with, also given to service containers and image builds
 
 	PresetGitHubContext   *model.GithubContext // the preset github context, overrides some fields like DefaultBranch, Env, Secrets etc.
 	EventJSON             string               // the content of JSON file to use for event.json in containers, overrides EventPath
@@ -93,16 +91,6 @@ type Config struct {
 	InsecureSkipTLS                   bool                         // whether to skip verifying TLS certificate of the Gitea instance
 	MaxParallel                       int                          // max parallel jobs to run across all workflows (0 = no limit, uses CPU count)
 	AllocatePTY                       bool                         // allocate a pseudo-TTY for each step's process
-	RunnerName                        string                       // name this runner registered with, reported as `runner.name`, defaults to the hostname
-	JobStartedHook                    string                       // script run inside the job environment before the job's first step; ACTIONS_RUNNER_HOOK_JOB_STARTED is read from Env when empty
-	JobCompletedHook                  string                       // script run inside the job environment after the job's last step; ACTIONS_RUNNER_HOOK_JOB_COMPLETED is read from Env when empty
-}
-
-// RunnerDebug reports whether debug logging is on, exposed as `runner.debug` and
-// RUNNER_DEBUG. Only the secret also makes the reporter keep ::debug:: output, the env
-// is accepted for `exec` and for runners configured with it.
-func (c Config) RunnerDebug() bool {
-	return c.Secrets["ACTIONS_STEP_DEBUG"] == "true" || c.Env["ACTIONS_STEP_DEBUG"] == "true"
 }
 
 // GetToken: Adapt to Gitea
@@ -148,11 +136,6 @@ func New(runnerConfig *Config) (Runner, error) {
 }
 
 func (runner *runnerImpl) configure() (Runner, error) {
-	if runner.config.RunnerName == "" {
-		// Callers that do not register, such as `exec`, still get a `runner.name`.
-		runner.config.RunnerName, _ = os.Hostname()
-	}
-
 	runner.eventJSON = "{}"
 	if runner.config.EventJSON != "" {
 		runner.eventJSON = runner.config.EventJSON

act/runner/runner_max_parallel_test.go

@@ -0,0 +1,109 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package runner
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestMaxParallelConfig tests that MaxParallel config is properly set
+func TestMaxParallelConfig(t *testing.T) {
+	t.Run("MaxParallel set to 2", func(t *testing.T) {
+		config := &Config{
+			Workdir:     "testdata",
+			MaxParallel: 2,
+		}
+
+		runner, err := New(config)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+		assert.NotNil(t, runner)
+
+		// Verify config is properly stored
+		runnerImpl, ok := runner.(*runnerImpl)
+		assert.True(t, ok)
+		assert.Equal(t, 2, runnerImpl.config.MaxParallel)
+	})
+
+	t.Run("MaxParallel set to 0 (no limit)", func(t *testing.T) {
+		config := &Config{
+			Workdir:     "testdata",
+			MaxParallel: 0,
+		}
+
+		runner, err := New(config)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+		assert.NotNil(t, runner)
+
+		runnerImpl, ok := runner.(*runnerImpl)
+		assert.True(t, ok)
+		assert.Equal(t, 0, runnerImpl.config.MaxParallel)
+	})
+
+	t.Run("MaxParallel not set (defaults to 0)", func(t *testing.T) {
+		config := &Config{
+			Workdir: "testdata",
+		}
+
+		runner, err := New(config)
+		assert.NoError(t, err) //nolint:testifylint // pre-existing issue from nektos/act
+		assert.NotNil(t, runner)
+
+		runnerImpl, ok := runner.(*runnerImpl)
+		assert.True(t, ok)
+		assert.Equal(t, 0, runnerImpl.config.MaxParallel)
+	})
+}
+
+// TestMaxParallelConcurrencyTracking tests that max-parallel actually limits concurrent execution
+func TestMaxParallelConcurrencyTracking(t *testing.T) {
+	// This is a unit test for the parallel executor logic
+	// We test that when MaxParallel is set, it limits the number of workers
+
+	var mu sync.Mutex
+	var maxConcurrent int
+	var currentConcurrent int
+
+	// Create a function that tracks concurrent execution
+	trackingFunc := func() {
+		mu.Lock()
+		currentConcurrent++
+		if currentConcurrent > maxConcurrent {
+			maxConcurrent = currentConcurrent
+		}
+		mu.Unlock()
+
+		// Simulate work
+		time.Sleep(50 * time.Millisecond)
+
+		mu.Lock()
+		currentConcurrent--
+		mu.Unlock()
+	}
+
+	// Run multiple tasks with limited parallelism
+	maxConcurrent = 0
+	currentConcurrent = 0
+
+	// This simulates what NewParallelExecutor does with a semaphore
+	var wg sync.WaitGroup
+	semaphore := make(chan struct{}, 2) // Limit to 2 concurrent
+
+	for range 6 {
+		wg.Go(func() {
+			semaphore <- struct{}{}        // Acquire
+			defer func() { <-semaphore }() // Release
+			trackingFunc()
+		})
+	}
+
+	wg.Wait()
+
+	// With a semaphore of 2, max concurrent should be <= 2
+	assert.LessOrEqual(t, maxConcurrent, 2, "Maximum concurrent executions should not exceed limit")
+	assert.GreaterOrEqual(t, maxConcurrent, 1, "Should have at least 1 concurrent execution")
+}

act/runner/runner_test.go

@@ -13,7 +13,6 @@ import (
 	"path"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -164,12 +163,6 @@ func TestGraphEvent(t *testing.T) {
 	assert.Empty(t, plan.Stages)
 }
 
-// these two build the same action Dockerfiles into one image tag, so they cannot overlap
-var sharedImageWorkflows = []string{"local-action-dockerfile", "local-action-via-composite-dockerfile"}
-
-// bounds concurrent plans: each job holds a network, and the daemon's address pool is finite
-var planSlots = make(chan struct{}, 4)
-
 type TestJobFileInfo struct {
 	workdir      string
 	workflowPath string
@@ -189,19 +182,12 @@ func (j *TestJobFileInfo) runTest(ctx context.Context, t *testing.T, cfg *Config
 
 	fullWorkflowPath := filepath.Join(workdir, j.workflowPath)
 	runnerConfig := &Config{
-		Workdir:     workdir,
+		Workdir:               workdir,
-		BindWorkdir: false,
+		BindWorkdir:           false,
-		EventName:   j.eventName,
+		EventName:             j.eventName,
-		EventPath:   cfg.EventPath,
+		EventPath:             cfg.EventPath,
-		Platforms:   j.platforms,
+		Platforms:             j.platforms,
-		// fixtures reuse workflow and job names, so parallel tests would collide without this
+		ReuseContainers:       false,
-		ContainerNamePrefix: strings.ReplaceAll(t.Name(), "/", "-"),
-		ReuseContainers:     false,
-		// as the shipped runner does, else a fixture asserting a job failure keeps its
-		// container, and its network, on the daemon forever
-		AutoRemove: true,
-		// 0 would run jobs runtime.NumCPU()-wide, making the network peak machine-dependent
-		MaxParallel:           2,
 		ForceRebuild:          true,
 		Env:                   cfg.Env,
 		Secrets:               cfg.Secrets,
@@ -224,11 +210,7 @@ func (j *TestJobFileInfo) runTest(ctx context.Context, t *testing.T, cfg *Config
 	plan, err := planner.PlanEvent(j.eventName)
 	assert.True(t, (err == nil) != (plan == nil), "PlanEvent should return either a plan or an error") //nolint:testifylint // pre-existing issue from nektos/act
 	if err == nil && plan != nil {
-		err = func() error {
+		err = runner.NewPlanExecutor(plan)(ctx)
-			planSlots <- struct{}{}
-			defer func() { <-planSlots }()
-			return runner.NewPlanExecutor(plan)(ctx)
-		}()
 		if j.errorMessage == "" {
 			assert.NoError(t, err, fullWorkflowPath) //nolint:testifylint // pre-existing issue from nektos/act
 		} else {
@@ -245,7 +227,6 @@ type TestConfig struct {
 
 func TestRunEvent(t *testing.T) {
 	requireDocker(t)
-	t.Parallel()
 
 	ctx := context.Background()
 
@@ -322,7 +303,6 @@ func TestRunEvent(t *testing.T) {
 		// services
 		{workdir, "services", "push", "", platforms, secrets},
 		{workdir, "services-with-container", "push", "", platforms, secrets},
-		{workdir, "services-empty-image", "push", "", platforms, secrets},
 
 		// local remote action overrides
 		{workdir, "local-remote-action-overrides", "push", "", platforms, secrets},
@@ -334,9 +314,6 @@ func TestRunEvent(t *testing.T) {
 				// host /proc bind mounts are Linux-Docker-only
 				requireLinuxDocker(t)
 			}
-			if !slices.Contains(sharedImageWorkflows, table.workflowPath) {
-				t.Parallel()
-			}
 
 			config := &Config{
 				Secrets: table.secrets,
@@ -467,7 +444,6 @@ func TestRunEventHostEnvironment(t *testing.T) {
 }
 
 func TestDryrunEvent(t *testing.T) {
-	t.Parallel()
 	// Dryrun plans without containers or network (shells and local actions only).
 	ctx := common.WithDryrun(context.Background(), true)
 
@@ -487,7 +463,6 @@ func TestDryrunEvent(t *testing.T) {
 
 	for _, table := range tables {
 		t.Run(table.workflowPath, func(t *testing.T) {
-			t.Parallel()
 			table.runTest(ctx, t, &Config{})
 		})
 	}
@@ -498,11 +473,33 @@ func TestDryrunEvent(t *testing.T) {
 // workflow's outputs via `needs`).
 func TestReusableWorkflowCaller(t *testing.T) {
 	requireDocker(t)
-	t.Parallel()
 	table := TestJobFileInfo{workdir, "uses-workflow", "push", "", platforms, map[string]string{"secret": "keep_it_private"}}
 	table.runTest(context.Background(), t, &Config{Secrets: table.secrets})
 }
 
+func TestDockerActionForcePullForceRebuild(t *testing.T) {
+	requireDocker(t)
+	requireNetwork(t) // force-pulls a docker action image
+
+	ctx := context.Background()
+
+	config := &Config{
+		ForcePull:    true,
+		ForceRebuild: true,
+	}
+
+	tables := []TestJobFileInfo{
+		{workdir, "local-action-dockerfile", "push", "", platforms, secrets},
+		{workdir, "local-action-via-composite-dockerfile", "push", "", platforms, secrets},
+	}
+
+	for _, table := range tables {
+		t.Run(table.workflowPath, func(t *testing.T) {
+			table.runTest(ctx, t, config)
+		})
+	}
+}
+
 type maskJobLoggerFactory struct {
 	Output bytes.Buffer
 }
@@ -515,7 +512,6 @@ func (f *maskJobLoggerFactory) WithJobLogger() *log.Logger {
 }
 
 func TestMaskValues(t *testing.T) {
-	t.Parallel()
 	assertNoSecret := func(text, secret string) { //nolint:unparam // pre-existing issue from nektos/act
 		found := strings.Contains(text, "composite secret")
 		if found {
@@ -546,7 +542,6 @@ func TestMaskValues(t *testing.T) {
 
 func TestRunEventSecrets(t *testing.T) {
 	requireDocker(t)
-	t.Parallel()
 	workflowPath := "secrets"
 
 	tjfi := TestJobFileInfo{
@@ -602,7 +597,6 @@ func TestRunWithService(t *testing.T) {
 }
 
 func TestRunActionInputs(t *testing.T) {
-	t.Parallel()
 	requireDocker(t)
 	workflowPath := "input-from-cli"
 
@@ -622,7 +616,6 @@ func TestRunActionInputs(t *testing.T) {
 }
 
 func TestRunEventPullRequest(t *testing.T) {
-	t.Parallel()
 	requireDocker(t)
 
 	workflowPath := "pull-request"
@@ -639,7 +632,6 @@ func TestRunEventPullRequest(t *testing.T) {
 }
 
 func TestRunMatrixWithUserDefinedInclusions(t *testing.T) {
-	t.Parallel()
 	requireDocker(t)
 	workflowPath := "matrix-with-user-inclusions"
 

act/runner/step.go

@@ -107,13 +107,7 @@ func runStepExecutor(step step, stage stepStage, executor common.Executor) commo
 		if strings.Contains(stepString, "::add-mask::") {
 			stepString = "add-mask command"
 		}
-		if stage == stepStageMain {
+		logger.Infof("Run %s %s", stage, stepString)
-			// Main steps print their own raw "Run <title>" header, so this line is redundant and
-			// only leaks into the "Set up job" section for the first step; keep it as a debug trace.
-			logger.Debugf("Run %s %s", stage, stepString)
-		} else {
-			logger.Infof("Run %s %s", stage, stepString)
-		}
 
 		// Prepare and clean Runner File Commands
 		actPath := rc.JobContainer.GetActPath()
@@ -181,7 +175,7 @@ func runStepExecutor(step step, stage stepStage, executor common.Executor) commo
 			}
 
 			if continueOnError {
-				logger.Errorf("##[error]%s", escapeCommandData(err.Error()))
+				logger.Errorf("##[error]%v", err)
 				logger.Infof("Failed but continue next step")
 				err = nil
 				stepResult.Conclusion = model.StepStatusSuccess

act/runner/step_action_remote.go

@@ -131,17 +131,14 @@ func (sar *stepActionRemote) prepareActionExecutor() common.Executor {
 			Token:       token,
 			OfflineMode: sar.RunContext.Config.ActionOfflineMode,
 			Depth:       sar.RunContext.Config.ActionCloneDepth,
-			// printPrepareActions reports the download with its resolved commit.
-			Quiet: true,
 
 			InsecureSkipTLS: sar.cloneSkipTLS(), // For Gitea
 		})
 		var ntErr common.Executor
 		if err := gitClone(ctx); err != nil {
-			var refErr *git.Error
+			if errors.Is(err, git.ErrShortRef) {
-			if errors.As(err, &refErr) && errors.Is(err, git.ErrShortRef) {
 				return fmt.Errorf("Unable to resolve action `%s`, the provided ref `%s` is the shortened version of a commit SHA, which is not supported. Please use the full commit SHA `%s` instead",
-					sar.Step.Uses, sar.remoteAction.Ref, refErr.Commit())
+					sar.Step.Uses, sar.remoteAction.Ref, err.(*git.Error).Commit())
 			} else if errors.Is(err, gogit.ErrForceNeeded) { // TODO: figure out if it will be easy to shadow/alias go-git err's
 				ntErr = common.NewInfoExecutor("Non-terminating error while running 'git clone': %v", err)
 			} else {
@@ -149,13 +146,6 @@ func (sar *stepActionRemote) prepareActionExecutor() common.Executor {
 			}
 		}
 
-		// Best effort: the download report falls back to the ref alone when the commit is unknown.
-		if _, sha, err := git.FindGitRevision(ctx, actionDir); err != nil {
-			common.Logger(ctx).Debugf("unable to resolve the commit of %s: %v", sar.remoteAction.Reference(), err)
-		} else {
-			sar.resolvedSha = sha
-		}
-
 		remoteReader := func(ctx context.Context) actionYamlReader { //nolint:unparam // pre-existing issue from nektos/act
 			return func(filename string) (io.Reader, io.Closer, error) {
 				f, err := os.Open(filepath.Join(actionDir, sar.remoteAction.Path, filename))
@@ -175,15 +165,6 @@ func (sar *stepActionRemote) prepareActionExecutor() common.Executor {
 	}
 }
 
-// actionDownloadInfo reports the action this step downloaded and the commit it resolved to. ok is
-// false when nothing was fetched, as for the local checkout of the workflow's own repository.
-func (sar *stepActionRemote) actionDownloadInfo() (reference, sha string, ok bool) {
-	if sar.remoteAction == nil || sar.action == nil {
-		return "", "", false
-	}
-	return sar.remoteAction.Reference(), sar.resolvedSha, true
-}
-
 func (sar *stepActionRemote) pre() common.Executor {
 	sar.env = map[string]string{}
 
@@ -332,16 +313,6 @@ func (ra *remoteAction) CloneURL(u string) string {
 	return fmt.Sprintf("%s/%s/%s", u, ra.Org, ra.Repo)
 }
 
-// Reference renders the action as {org}/{repo}[/path]@{ref}, omitting the download source, which
-// can be interpolated from a secret.
-func (ra *remoteAction) Reference() string {
-	repo := fmt.Sprintf("%s/%s", ra.Org, ra.Repo)
-	if ra.Path != "" {
-		repo = fmt.Sprintf("%s/%s", repo, ra.Path)
-	}
-	return fmt.Sprintf("%s@%s", repo, ra.Ref)
-}
-
 func (ra *remoteAction) IsCheckout() bool {
 	if ra.Org == "actions" && ra.Repo == "checkout" {
 		return true

act/runner/step_action_remote_test.go

@@ -10,9 +10,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -821,97 +818,6 @@ func Test_newRemoteAction(t *testing.T) {
 	}
 }
 
-func Test_remoteActionReference(t *testing.T) {
-	tests := []struct {
-		uses string
-		want string
-	}{
-		{uses: "actions/checkout@v7", want: "actions/checkout@v7"},
-		{uses: "actions/aws/ec2@main", want: "actions/aws/ec2@main"},
-		// The download source can be interpolated from a secret and must stay out of the log.
-		{uses: "https://gitea.example.com/actions/checkout@v7", want: "actions/checkout@v7"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.uses, func(t *testing.T) {
-			assert.Equal(t, tt.want, newRemoteAction(tt.uses).Reference())
-		})
-	}
-}
-
-// TestStepActionRemotePreResolvesDownloadedCommit runs the real download path against a local
-// git repository standing in for the actions instance, so the reported commit is the one the
-// clone actually checked out.
-func TestStepActionRemotePreResolvesDownloadedCommit(t *testing.T) {
-	instance := t.TempDir()
-	actionDir := filepath.Join(instance, "actions", "setup-go")
-	require.NoError(t, os.MkdirAll(actionDir, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(actionDir, "action.yml"),
-		[]byte("name: setup-go\nruns:\n  using: node20\n  main: index.js\n"), 0o600))
-
-	// Supply an identity on the commit so the test does not depend on a
-	// git identity being configured in the environment; a CI runner without
-	// user.name/user.email would otherwise fail "commit" with exit code 128.
-	for _, args := range [][]string{
-		{"init", "--initial-branch=main", actionDir},
-		{"-C", actionDir, "add", "action.yml"},
-		{"-C", actionDir, "-c", "user.name=runner", "-c", "user.email=runner@example.com", "-c", "commit.gpgsign=false", "commit", "-m", "action"},
-	} {
-		cmd := exec.Command("git", args...)
-		require.NoError(t, cmd.Run(), "git %v", args)
-	}
-	out, err := exec.Command("git", "-C", actionDir, "rev-parse", "HEAD").Output()
-	require.NoError(t, err)
-	wantSha := strings.TrimSpace(string(out))
-
-	sar := &stepActionRemote{
-		Step: &model.Step{Uses: "actions/setup-go@main"},
-		RunContext: &RunContext{
-			Config: &Config{
-				GitHubInstance:        "https://gitea.example.com",
-				DefaultActionInstance: instance,
-				ActionCacheDir:        t.TempDir(),
-			},
-			Run: &model.Run{
-				JobID:    "1",
-				Workflow: &model.Workflow{Jobs: map[string]*model.Job{"1": {}}},
-			},
-		},
-		readAction: readActionImpl,
-	}
-
-	require.NoError(t, sar.prepareActionExecutor()(context.Background()))
-
-	reference, sha, ok := sar.actionDownloadInfo()
-	assert.True(t, ok)
-	assert.Equal(t, "actions/setup-go@main", reference)
-	assert.Equal(t, wantSha, sha)
-}
-
-func TestStepActionRemoteActionDownloadInfo(t *testing.T) {
-	t.Run("reports the action and its resolved commit", func(t *testing.T) {
-		sar := &stepActionRemote{
-			remoteAction: newRemoteAction("actions/checkout@v7"),
-			action:       &model.Action{},
-			resolvedSha:  "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0",
-		}
-
-		reference, sha, ok := sar.actionDownloadInfo()
-
-		assert.True(t, ok)
-		assert.Equal(t, "actions/checkout@v7", reference)
-		assert.Equal(t, "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0", sha)
-	})
-
-	t.Run("reports nothing when no action was downloaded", func(t *testing.T) {
-		// The local checkout of the workflow's own repository resolves no action.
-		sar := &stepActionRemote{remoteAction: newRemoteAction("actions/checkout@v7")}
-
-		_, _, ok := sar.actionDownloadInfo()
-
-		assert.False(t, ok)
-	})
-}
-
 func Test_safeFilename(t *testing.T) {
 	tests := []struct {
 		s    string

act/runner/step_docker.go

@@ -85,7 +85,7 @@ func (sd *stepDocker) runUsesContainer() common.Executor {
 			stepContainer.Create(rc.Config.ContainerCapAdd, rc.Config.ContainerCapDrop),
 			stepContainer.Start(true),
 		).Finally(
-			stepContainer.Remove().IfBool(!rc.Config.ReuseContainers && !rc.Config.AutoRemove),
+			stepContainer.Remove().IfBool(!rc.Config.ReuseContainers),
 		).Finally(stepContainer.Close())(ctx)
 	}
 }
@@ -110,7 +110,10 @@ func (sd *stepDocker) newStepContainer(ctx context.Context, image string, cmd, e
 		envList = append(envList, fmt.Sprintf("%s=%s", k, v))
 	}
 
-	envList = append(envList, rc.runnerEnv(ctx)...)
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TOOL_CACHE", "/opt/hostedtoolcache"))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_OS", "Linux"))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_ARCH", container.RunnerArch(ctx)))
+	envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TEMP", "/tmp"))
 
 	binds, mounts := rc.GetBindsAndMounts()
 	networkMode := "container:" + rc.jobContainerName()

act/runner/step_docker_test.go

@@ -16,7 +16,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 func TestStepDockerMain(t *testing.T) {
@@ -119,43 +118,6 @@ func TestStepDockerMain(t *testing.T) {
 	cm.AssertExpectations(t)
 }
 
-// With AutoRemove the daemon reaps the container on exit, so act must not remove it afterwards.
-func TestStepDockerAutoRemove(t *testing.T) {
-	orig := ContainerNewContainer
-	defer func() { ContainerNewContainer = orig }()
-
-	for _, tc := range []struct {
-		autoRemove bool
-		removes    int
-	}{
-		{false, 2}, // stale + post-run
-		{true, 1},  // post-run skipped
-	} {
-		cm := &containerMock{}
-		ContainerNewContainer = func(*container.NewContainerInput) container.ExecutionsEnvironment { return cm }
-
-		sd := &stepDocker{
-			RunContext: &RunContext{
-				Config:       &Config{AutoRemove: tc.autoRemove},
-				Run:          &model.Run{JobID: "1", Workflow: &model.Workflow{Jobs: map[string]*model.Job{"1": {}}}},
-				JobContainer: cm,
-			},
-			Step: &model.Step{ID: "1", Uses: "docker://node:14"},
-		}
-
-		removes := 0
-		cm.On("Pull", false).Return(func(context.Context) error { return nil })
-		cm.On("Remove").Return(func(context.Context) error { removes++; return nil })
-		cm.On("Create", []string(nil), []string(nil)).Return(func(context.Context) error { return nil })
-		cm.On("Start", true).Return(func(context.Context) error { return nil })
-		cm.On("Close").Return(func(context.Context) error { return nil })
-
-		require.NoError(t, sd.runUsesContainer()(context.Background()))
-		cm.AssertExpectations(t)
-		assert.Equal(t, tc.removes, removes)
-	}
-}
-
 func TestStepDockerNewStepContainerAllocatePTY(t *testing.T) {
 	for _, tc := range []struct {
 		name     string

act/runner/step_run.go

@@ -63,7 +63,7 @@ func (sr *stepRun) printRunScriptActionDetails(ctx context.Context) {
 
 	normalized := strings.TrimRight(strings.ReplaceAll(sr.interpolatedScript, "\r\n", "\n"), "\n")
 
-	rawLogger.Infof("::group::Run %s", escapeCommandData(sr.runScriptGroupTitle(normalized)))
+	rawLogger.Infof("::group::Run %s", sr.runScriptGroupTitle(normalized))
 
 	if normalized != "" {
 		for line := range strings.SplitSeq(normalized, "\n") {
@@ -90,7 +90,7 @@ func printRunActionHeader(ctx context.Context, step *model.Step, env map[string]
 	if step.Name != "" {
 		title = step.Name
 	}
-	rawLogger.Infof("::group::Run %s", escapeCommandData(title))
+	rawLogger.Infof("::group::Run %s", title)
 
 	if len(step.With) > 0 {
 		rawLogger.Infof("with:")

act/runner/step_test.go

@@ -167,9 +167,6 @@ func TestSetupEnv(t *testing.T) {
 	delete((env), "GITHUB_REPOSITORY")
 	delete((env), "GITHUB_REPOSITORY_OWNER")
 	delete((env), "GITHUB_ACTOR")
-	// Host-dependent, asserted in TestRunContextWithGithubEnvRunnerValues instead.
-	delete((env), "RUNNER_NAME")
-	delete((env), "RUNNER_WORKSPACE")
 
 	assert.Equal(t, map[string]string{
 		"ACT":                      "true",
@@ -195,7 +192,6 @@ func TestSetupEnv(t *testing.T) {
 		"GITHUB_WORKFLOW":          "",
 		"INPUT_STEP_WITH":          "with-value",
 		"RC_KEY":                   "rcvalue",
-		"RUNNER_ENVIRONMENT":       "self-hosted",
 		"RUNNER_PERFLOG":           "/dev/null",
 		"RUNNER_TRACKING_ID":       "",
 	}, env)

act/runner/testdata/actions/action1/Dockerfile

@@ -1 +1 @@
-FROM ubuntu:26.04
+FROM ubuntu:24.04

act/runner/testdata/services-empty-image/push.yml

@@ -1,10 +0,0 @@
-name: services-empty-image
-on: push
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    services:
-      db:
-        image: ${{ false && 'postgres:16' || '' }}
-    steps:
-      - run: echo "empty-image service was skipped"

act/runner/testdata/workflow_call_inputs/event.json

@@ -1,6 +1,6 @@
 {
   "inputs": {
     "required": "required input",
-    "boolean": true
+    "boolean": "true"
   }
 }

docs/job-hooks.md

@@ -1,70 +0,0 @@
-# Job hooks
-
-Job hooks are operator-provided scripts that run **inside the job environment**, before the job's first step and after its last one. They are the equivalent of GitHub's [job hooks](https://docs.github.com/en/actions/how-tos/manage-runners/self-hosted-runners/run-scripts) and are configured under `runner.hooks` in the runner YAML config (see [config.example.yaml](../internal/pkg/config/config.example.yaml)):
-
-```yaml
-runner:
-  hooks:
-    job_started: /hooks/started.sh
-    job_completed: /hooks/completed.sh
-```
-
-| Setting | Runs |
-| --- | --- |
-| `runner.hooks.job_started` | Before the job's first step, before any action is downloaded |
-| `runner.hooks.job_completed` | After the job's last post step, while the job environment is still up |
-
-`ACTIONS_RUNNER_HOOK_JOB_STARTED` and `ACTIONS_RUNNER_HOOK_JOB_COMPLETED` are read from the runner's environment (`runner.envs`, `runner.env_file`) when the settings are unset, so a configuration carried over from actions/runner keeps working. The settings take precedence. A workflow cannot point the runner at a different hook: the variables are only read from the runner's own environment, never from the job's.
-
-Both hooks are **synchronous** and block the job while they run, and a non-zero exit from either one fails the job. There is no `continue-on-error` and no per-hook timeout — the job's own `runner.timeout` is the only bound. The operator is responsible for the hook's resilience; run anything long in the background from within the hook.
-
-## Where they run
-
-The hooks run in the same place as the job's steps: inside the job container, or on the host in host mode. The paths are resolved *there*, so the script has to exist in the job image or on the host — a path that only exists on the runner host is not visible to a containerized job. For host-wide cleanup that runs after the job environment is gone, use the [post-task script](post-task-script.md) instead.
-
-> This is a deliberate difference from actions/runner, which runs its job hooks on the host, outside any container the job declares. Running them where the steps run is what lets a hook prepare the environment the steps actually see.
-
-The script is run according to its extension:
-
-| Extension | Command |
-| --- | --- |
-| `.sh` | `bash -e <path>` |
-| `.ps1` | `pwsh -command . '<path>'` |
-| anything else | the file itself, which needs its own shebang and executable bit |
-
-As on GitHub, the shell flags applied to `run:` steps are **not** applied to a hook — set `pipefail` or anything else you want inside the script.
-
-### Docker-in-Docker and Docker-out-of-Docker
-
-The hook is executed and its files are exchanged over the Docker API, addressed by container ID, so no path is translated between the runner and the daemon. Both setups work unchanged, but they differ in where the hook file has to be:
-
-- **DinD** — the daemon has its own filesystem. Bake the hook into the job image; a path from the runner's filesystem is not visible to it.
-- **DooD** — the job container is created by the host's daemon, so a bind mount in `container.options` is resolved against the **host**, not against the runner container. Either bake the hook into the job image, or mount a host directory and add it to `container.valid_volumes`.
-
-A hook path that does not exist inside the job environment fails the job with `No such file or directory`, naming the path.
-
-## Environment
-
-A hook sees the job's environment: the workflow, job and `container:` `env:`, the runner's `envs`, and the `GITHUB_*` context variables, with the same masking applied to its output as to a step's. The step-specific ones (`GITHUB_ACTION`, `GITHUB_OUTPUT`, `GITHUB_STATE`) are not set — a hook is not a step, so `::save-state::` and `::set-output::` have nowhere to go.
-
-Its stdout is part of the job log, inside a collapsible group, and is scanned for workflow commands. `::add-mask::` registers a value to be masked for the rest of the job, `::set-env::` and `::add-path::` apply to the steps that follow.
-
-`$GITHUB_ENV` and `$GITHUB_PATH` point at files that are read back after the hook exits, so the file-command form works too:
-
-```bash
-#!/bin/bash
-echo "REGISTRY_TOKEN=$(fetch-token)" >> "$GITHUB_ENV"
-echo "/opt/tooling/bin" >> "$GITHUB_PATH"
-```
-
-Both files are the hook's own, separate from the per-step ones, so nothing a hook writes is truncated by the first step.
-
-## Recommendations
-
-- Keep hooks **fast** and return the right exit code: they are on the critical path of every job, and nothing bounds them.
-- Use **idempotent** operations, and expect `job_completed` to run after success, failure, and cancellation alike.
-- Mask anything secret the hook prints or exports with `::add-mask::`.
-
-## See also
-
-- [Post-task script](post-task-script.md) — host-side cleanup after the job environment is torn down.

docs/post-task-script.md

@@ -150,7 +150,6 @@ powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "%~dp0po
 
 ## See also
 
-- [Job hooks](job-hooks.md) — scripts running inside the job environment, around its steps
 - [Configuration](../README.md#configuration) — generating and loading `config.yaml`
 - [config.example.yaml](../internal/pkg/config/config.example.yaml) — all runner options
 - Bind-workdir idle cleanup (`runner.workdir_cleanup_age`) — separate from this hook; runs only when the runner is idle

examples/kubernetes/README.md

@@ -6,11 +6,6 @@ NOTE: `dind-docker.yaml` uses the native sidecar pattern (init container with `r
 
 NOTE: A helm chart for `gitea-runner` also exists for easier deployments https://gitea.com/gitea/helm-actions
 
-Each example persists **two** things, and it is worth knowing which is which:
-
-- `/data` is the runner's working directory. It holds the `.runner` registration file and, optionally, the config file — so the runner re-attaches to the server instead of registering again.
-- The Docker daemon's data root holds the images pulled for jobs (`/var/lib/docker` for the dind sidecar, `/home/rootless/.local/share/docker` for `dind-rootless`). It is *not* under `/data`. If you drop this volume, the examples still work, but the image cache is discarded whenever the pod is recreated and every job re-pulls its images.
-
 Files in this directory:
 
 - [`dind-docker.yaml`](dind-docker.yaml)
@@ -18,6 +13,3 @@ Files in this directory:
 
 - [`rootless-docker.yaml`](rootless-docker.yaml)
   How to create a rootless Deployment and Persistent Volume for Kubernetes to act as a runner. The Docker credentials are re-generated each time the pod connects and does not need to be persisted.
-
-- [`statefulset-dind.yaml`](statefulset-dind.yaml)
-  StatefulSet variant of the dind example. Each replica gets a stable identity and its own persistent volume via `volumeClaimTemplates`, so the runner keeps its `.runner` registration across restarts and reschedules instead of trying to register again.

examples/kubernetes/dind-docker.yaml

@@ -1,5 +1,3 @@
-# Holds the runner's working directory (/data): the .runner registration file
-# and, optionally, the config file.
 kind: PersistentVolumeClaim
 apiVersion: v1
 metadata:
@@ -12,21 +10,6 @@ spec:
       storage: 1Gi
   storageClassName: standard
 ---
-# Holds the Docker daemon's data root (/var/lib/docker), i.e. the images pulled
-# for jobs. Without it, the image cache is lost whenever the pod is recreated
-# and every job re-pulls its images. Size it for the images you expect to cache.
-kind: PersistentVolumeClaim
-apiVersion: v1
-metadata:
-  name: docker-vol
-spec:
-  accessModes:
-  - ReadWriteOnce
-  resources:
-    requests:
-      storage: 20Gi
-  storageClassName: standard
----
 apiVersion: v1
 data:
   # The registration token can be obtained from the web UI, API or command-line.
@@ -62,9 +45,6 @@ spec:
       - name: runner-data
         persistentVolumeClaim:
           claimName: runner-vol
-      - name: docker-data
-        persistentVolumeClaim:
-          claimName: docker-vol
       initContainers:
       - name: docker
         image: docker:28.2.2-dind
@@ -73,8 +53,6 @@ spec:
         volumeMounts:
         - name: docker-socket
           mountPath: /var/run
-        - name: docker-data
-          mountPath: /var/lib/docker
         startupProbe:
           exec:
             command: ["/usr/bin/test", "-S", "/var/run/docker.sock"]

examples/kubernetes/rootless-docker.yaml

@@ -1,5 +1,3 @@
-# Holds the runner's working directory (/data): the .runner registration file
-# and, optionally, the config file.
 kind: PersistentVolumeClaim
 apiVersion: v1
 metadata:
@@ -12,21 +10,6 @@ spec:
       storage: 1Gi
   storageClassName: standard
 ---
-# Holds the rootless Docker daemon's data root, i.e. the images pulled for jobs.
-# Without it, the image cache is lost whenever the pod is recreated and every job
-# re-pulls its images. Size it for the images you expect to cache.
-kind: PersistentVolumeClaim
-apiVersion: v1
-metadata:
-  name: docker-vol
-spec:
-  accessModes:
-  - ReadWriteOnce
-  resources:
-    requests:
-      storage: 20Gi
-  storageClassName: standard
----
 apiVersion: v1
 data:
   # The registration token can be obtained from the web UI, API or command-line.
@@ -60,12 +43,7 @@ spec:
       - name: runner-data
         persistentVolumeClaim:
           claimName: runner-vol
-      - name: docker-data
-        persistentVolumeClaim:
-          claimName: docker-vol
       securityContext:
-        # The dind-rootless image runs as the `rootless` user (UID/GID 1000);
-        # fsGroup makes both volumes writable for it.
         fsGroup: 1000
       containers:
       - name: runner
@@ -90,7 +68,4 @@ spec:
         volumeMounts:
         - name: runner-data
           mountPath: /data
-        # The rootless daemon keeps its images here, not under /data.
-        - name: docker-data
-          mountPath: /home/rootless/.local/share/docker
 

examples/kubernetes/statefulset-dind.yaml

@@ -1,96 +0,0 @@
-# StatefulSet variant of the dind example.
-#
-# Unlike the Deployment, a StatefulSet gives each replica a stable identity and,
-# via volumeClaimTemplates, its own persistent volume. That means every runner
-# pod keeps its own `.runner` registration file across restarts and reschedules,
-# so it re-attaches to the server instead of trying to register again.
-apiVersion: v1
-data:
-  # The registration token can be obtained from the web UI, API or command-line.
-  # You can also set a pre-defined global runner registration token for the Gitea instance via
-  # `GITEA_RUNNER_REGISTRATION_TOKEN`/`GITEA_RUNNER_REGISTRATION_TOKEN_FILE` environment variable.
-  token: << base64 encoded registration token >>
-kind: Secret
-metadata:
-  name: runner-secret
-type: Opaque
----
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  labels:
-    app: runner
-  name: runner
-spec:
-  serviceName: runner
-  replicas: 1
-  selector:
-    matchLabels:
-      app: runner
-  template:
-    metadata:
-      labels:
-        app: runner
-    spec:
-      restartPolicy: Always
-      volumes:
-      - name: docker-socket
-        emptyDir: {}
-      initContainers:
-      - name: docker
-        image: docker:28.2.2-dind
-        securityContext:
-          privileged: true
-        volumeMounts:
-        - name: docker-socket
-          mountPath: /var/run
-        # Keeps the images pulled for jobs across restarts. Without this, the
-        # daemon's data root is ephemeral and every job re-pulls its images.
-        - name: docker-data
-          mountPath: /var/lib/docker
-        startupProbe:
-          exec:
-            command: ["/usr/bin/test", "-S", "/var/run/docker.sock"]
-        livenessProbe:
-          exec:
-            command: ["/usr/bin/test", "-S", "/var/run/docker.sock"]
-        restartPolicy: Always
-      containers:
-      - name: runner
-        image: gitea/runner:nightly
-        env:
-        - name: GITEA_INSTANCE_URL
-          value: http://gitea-http.gitea.svc.cluster.local:3000
-        - name: GITEA_RUNNER_REGISTRATION_TOKEN
-          valueFrom:
-            secretKeyRef:
-              name: runner-secret
-              key: token
-        volumeMounts:
-        - name: runner-data
-          mountPath: /data
-        - name: docker-socket
-          mountPath: /var/run
-  volumeClaimTemplates:
-  # The runner's working directory: the .runner registration file and, optionally,
-  # the config file.
-  - metadata:
-      name: runner-data
-    spec:
-      accessModes:
-      - ReadWriteOnce
-      resources:
-        requests:
-          storage: 1Gi
-      storageClassName: standard
-  # The Docker daemon's data root: the images pulled for jobs. Size it for the
-  # images you expect to cache.
-  - metadata:
-      name: docker-data
-    spec:
-      accessModes:
-      - ReadWriteOnce
-      resources:
-        requests:
-          storage: 20Gi
-      storageClassName: standard

examples/systemd/README.md

@@ -1,34 +0,0 @@
-# Running the runner as a systemd service
-
-[`gitea-runner.service`](./gitea-runner.service) is an example unit for running
-the runner as a background service on a systemd host.
-
-## Setup
-
-1. Install the `gitea-runner` binary (e.g. to `/usr/local/bin/gitea-runner`).
-2. Create a dedicated user and working directory:
-
-   ```bash
-   sudo useradd --system --home-dir /var/lib/gitea-runner --create-home gitea-runner
-   ```
-
-3. Generate a config and register the runner (as the service user), so the
-   `.runner` file ends up in the working directory:
-
-   ```bash
-   sudo -u gitea-runner gitea-runner generate-config > /etc/gitea-runner/config.yaml
-   cd /var/lib/gitea-runner
-   sudo -u gitea-runner gitea-runner register --config /etc/gitea-runner/config.yaml
-   ```
-
-4. Install and enable the unit:
-
-   ```bash
-   sudo cp gitea-runner.service /etc/systemd/system/gitea-runner.service
-   sudo systemctl daemon-reload
-   sudo systemctl enable --now gitea-runner
-   ```
-
-Adjust the binary path, config path, working directory and user to match your
-installation. If jobs use the host's Docker daemon, uncomment the
-`docker.service` dependencies in the unit.

examples/systemd/gitea-runner.service

@@ -1,30 +0,0 @@
-[Unit]
-Description=Gitea Actions runner
-Documentation=https://gitea.com/gitea/runner
-After=network-online.target
-Wants=network-online.target
-# Uncomment when jobs use the local Docker daemon:
-# After=docker.service
-# Requires=docker.service
-
-[Service]
-Type=simple
-# Adjust the binary path, config path and working directory to your setup.
-# The working directory is where the .runner registration file is read from
-# unless runner.file is set to an absolute path in the config.
-ExecStart=/usr/local/bin/gitea-runner daemon --config /etc/gitea-runner/config.yaml
-WorkingDirectory=/var/lib/gitea-runner
-User=gitea-runner
-Group=gitea-runner
-
-# Restart automatically so the runner survives transient failures, e.g. the
-# Gitea instance being temporarily unreachable at startup.
-Restart=on-failure
-RestartSec=5s
-
-# Allow running jobs to finish before the runner is stopped. Keep this in sync
-# with runner.shutdown_timeout in the config.
-TimeoutStopSec=3h
-
-[Install]
-WantedBy=multi-user.target

go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/containerd/errdefs v1.0.0
 	github.com/creack/pty v1.1.24
 	github.com/distribution/reference v0.6.0
-	github.com/docker/cli v29.6.2+incompatible
+	github.com/docker/cli v29.6.1+incompatible
 	github.com/docker/go-connections v0.7.0
 	github.com/go-git/go-billy/v5 v5.9.0
 	github.com/go-git/go-git/v5 v5.19.1
@@ -20,7 +20,7 @@ require (
 	github.com/joho/godotenv v1.5.1
 	github.com/julienschmidt/httprouter v1.3.0
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51
-	github.com/mattn/go-isatty v0.0.23
+	github.com/mattn/go-isatty v0.0.22
 	github.com/moby/go-archive v0.2.0
 	github.com/moby/moby/api v1.55.0
 	github.com/moby/moby/client v0.5.0
@@ -28,8 +28,7 @@ require (
 	github.com/opencontainers/image-spec v1.1.1
 	github.com/opencontainers/selinux v1.15.1
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/client_golang v1.24.0
+	github.com/prometheus/client_golang v1.23.2
-	github.com/prometheus/client_model v0.6.2
 	github.com/rhysd/actionlint v1.7.12
 	github.com/sirupsen/logrus v1.9.4
 	github.com/spf13/cobra v1.10.2
@@ -38,10 +37,8 @@ require (
 	github.com/timshannon/bolthold v0.0.0-20240314194003-30aac6950928
 	go.etcd.io/bbolt v1.5.0
 	go.yaml.in/yaml/v4 v4.0.0-rc.3
-	golang.org/x/net v0.56.0
+	golang.org/x/sys v0.46.0
-	golang.org/x/sys v0.47.0
+	golang.org/x/term v0.44.0
-	golang.org/x/term v0.45.0
-	golang.org/x/text v0.40.0
 	google.golang.org/protobuf v1.36.11
 	gotest.tools/v3 v3.5.2
 	tags.cncf.io/container-device-interface v1.1.0
@@ -74,7 +71,7 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/kevinburke/ssh_config v1.6.0 // indirect
-	github.com/klauspost/compress v1.19.0 // indirect
+	github.com/klauspost/compress v1.18.5 // 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.21 // indirect
@@ -87,8 +84,9 @@ require (
 	github.com/opencontainers/go-digest v1.0.0 // indirect
 	github.com/pjbgf/sha1cd v0.6.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/common v0.70.0 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/procfs v0.21.1 // indirect
+	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/procfs v0.17.0 // 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
@@ -99,14 +97,16 @@ require (
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
 	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.44.0 // indirect
+	go.opentelemetry.io/otel v1.43.0 // indirect
-	go.opentelemetry.io/otel/metric v1.44.0 // indirect
+	go.opentelemetry.io/otel/metric v1.43.0 // indirect
 	go.opentelemetry.io/otel/sdk v1.43.0 // indirect
 	go.opentelemetry.io/otel/sdk/metric v1.43.0 // indirect
-	go.opentelemetry.io/otel/trace v1.44.0 // indirect
+	go.opentelemetry.io/otel/trace v1.43.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/crypto v0.53.0 // indirect
+	golang.org/x/crypto v0.52.0 // indirect
-	golang.org/x/sync v0.22.0 // indirect
+	golang.org/x/net v0.54.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -47,8 +47,12 @@ 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.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
 github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
-github.com/docker/cli v29.6.2+incompatible h1:/bjePvcbbFTnRrMfWJBY7AjfICdsiLVgHn6LwTVOcqw=
+github.com/docker/cli v29.5.3+incompatible h1:nbEFfz774vBwQ5KRYv7c/AghjReqnGISvrRhzjV0evs=
-github.com/docker/cli v29.6.2+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v29.5.3+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v29.6.0+incompatible h1:nw9himxMMZ7eIeherJNlKQq+acnlzGgHd+4uf10QRSc=
+github.com/docker/cli v29.6.0+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
+github.com/docker/cli v29.6.1+incompatible h1:oO7F4nn3Ovr/5TlfTUWFbMwBSS/B7Xs6Epv26gBrUP8=
+github.com/docker/cli v29.6.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/docker-credential-helpers v0.9.6 h1:cT2PbRPSlnMmNTfT2TDMXRyQ1KMWHG7xoTLBcn1ZNv0=
 github.com/docker/docker-credential-helpers v0.9.6/go.mod h1:v1S+hepowrQXITkEfw6o4+BMbGot02wiKpzWhGUZK6c=
 github.com/docker/go-connections v0.7.0 h1:6SsRfJddP22WMrCkj19x9WKjEDTB+ahsdiGYf0mN39c=
@@ -102,8 +106,8 @@ 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/klauspost/compress v1.19.0 h1:sXLILfc9jV2QYWkzFOPWStmcUVH2RHEB1JCdY2oVvCQ=
+github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
-github.com/klauspost/compress v1.19.0/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -117,8 +121,8 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
 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.23 h1:cYwCQTQf3HB6xUC+BtyCLZNr7IzbOmoZbmssVNzSyiQ=
+github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
-github.com/mattn/go-isatty v0.0.23/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
+github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
 github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w=
 github.com/mattn/go-runewidth v0.0.21/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
@@ -127,8 +131,12 @@ github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3N
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
 github.com/moby/go-archive v0.2.0 h1:zg5QDUM2mi0JIM9fdQZWC7U8+2ZfixfTYoHL7rWUcP8=
 github.com/moby/go-archive v0.2.0/go.mod h1:mNeivT14o8xU+5q1YnNrkQVpK+dnNe/K6fHqnTg4qPU=
+github.com/moby/moby/api v1.54.2 h1:wiat9QAhnDQjA7wk1kh/TqHz2I1uUA7M7t9SAl/JNXg=
+github.com/moby/moby/api v1.54.2/go.mod h1:+RQ6wluLwtYaTd1WnPLykIDPekkuyD/ROWQClE83pzs=
 github.com/moby/moby/api v1.55.0 h1:2/sexvQyqIWS8pRSCFddBfpW2qE7vR7FCL+vN8pxwMc=
 github.com/moby/moby/api v1.55.0/go.mod h1:+RQ6wluLwtYaTd1WnPLykIDPekkuyD/ROWQClE83pzs=
+github.com/moby/moby/client v0.4.1 h1:DMQgisVoMkmMs7fp3ROSdiBnoAu8+vo3GggFl06M/wY=
+github.com/moby/moby/client v0.4.1/go.mod h1:z52C9O2POPOsnxZAy//WtKcQ32P+jT/NGeXu/7nfjGQ=
 github.com/moby/moby/client v0.5.0 h1:5XhyPk2fuOWf6RlSFa3MkIIgDZkF25xToXW8Q/BH7cc=
 github.com/moby/moby/client v0.5.0/go.mod h1:rcVpF8ncl9vo5gaIBdol6CnbEtSj1uxMvEV/UrykF/s=
 github.com/moby/patternmatcher v0.6.1 h1:qlhtafmr6kgMIJjKJMDmMWq7WLkKIo23hsrpR3x084U=
@@ -155,14 +163,14 @@ 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.24.0 h1:5XStIklKuAtJSNpdD3s8XJj/Yv78IQmE1kbNk87JrAI=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
-github.com/prometheus/client_golang v1.24.0/go.mod h1:QcsNdotprC2nS4BTM2ucbcqxd2CeXTEa9jW7zHO9iDE=
+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.70.0 h1:bcpru3tWPVnxGnETLgOV5jbp/JRXgYEyv65CuBLAMMI=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
-github.com/prometheus/common v0.70.0/go.mod h1:S/SFasQmgGiYH6C81LKCtYa8QACgthGg5zxL2udV7SY=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
-github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
+github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
-github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
+github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
 github.com/rhysd/actionlint v1.7.12 h1:vQ4GeJN86C0QH+gTUQcs8McmK62OLT3kmakPMtEWYnY=
 github.com/rhysd/actionlint v1.7.12/go.mod h1:krOUhujIsJusovkaYzQ/VNH8PFexjNKqU0q5XI/4w+g=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
@@ -207,6 +215,8 @@ github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:
 github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 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=
 go.etcd.io/bbolt v1.5.0 h1:S7GAl7Fxv12yohbwFfIbQCGDWbQbtDGPET4P/bD4lxU=
 go.etcd.io/bbolt v1.5.0/go.mod h1:mkltfYE5aUHQxUct9N9V+Kp7aSjFqjgrhcXIS70Lrdk=
 go.etcd.io/gofail v0.1.0/go.mod h1:VZBCXYGZhHAinaBiiqYvuDynvahNsAyLFwB3kEHKz1M=
@@ -214,34 +224,34 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0 h1:7iP2uCb7sGddAr30RRS6xjKy7AZ2JtTOPA3oolgVSw8=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0/go.mod h1:c7hN3ddxs/z6q9xwvfLPk+UHlWRQyaeR1LdgfL/66l0=
-go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU=
+go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
-go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc=
+go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
-go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc=
+go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
-go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo=
+go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
 go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
 go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
 go.opentelemetry.io/otel/sdk/metric v1.43.0 h1:S88dyqXjJkuBNLeMcVPRFXpRw2fuwdvfCGLEo89fDkw=
 go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A=
-go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk=
+go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
-go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE=
+go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
 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.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
+go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
-go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
+go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 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-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=
-golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
 golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM=
 golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
-golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
+golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
-golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/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=
@@ -250,14 +260,14 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
-golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
+golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc=
-golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
+golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
-golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=

internal/app/cmd/bug_report.go

@@ -1,31 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"fmt"
-	"runtime"
-
-	"gitea.com/gitea/runner/internal/pkg/ver"
-
-	"github.com/spf13/cobra"
-)
-
-// loadBugReportCmd prints environment details that are useful when opening a
-// bug report, so users can paste them straight into an issue.
-func loadBugReportCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "bug-report",
-		Short: "Print information useful when filing a bug report",
-		Args:  cobra.MaximumNArgs(0),
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			w := cmd.OutOrStdout()
-			fmt.Fprintf(w, "Runner version: %s\n", ver.Version())
-			fmt.Fprintf(w, "Go version:     %s\n", runtime.Version())
-			fmt.Fprintf(w, "OS/Arch:        %s/%s\n", runtime.GOOS, runtime.GOARCH)
-			fmt.Fprintf(w, "NumCPU:         %d\n", runtime.NumCPU())
-			return nil
-		},
-	}
-}

internal/app/cmd/cache-server.go

@@ -50,7 +50,7 @@ func runCacheServer(configFile *string, cacheArgs *cacheServerArgs) func(cmd *co
 
 		secret := cfg.Cache.ExternalSecret
 		if secret == "" {
-			return errors.New("cache.external_secret (or cache.external_secret_file) must be set for cache-server; configure the same value on each runner that points at this server via cache.external_server")
+			return errors.New("cache.external_secret must be set for cache-server; configure the same value on each runner that points at this server via cache.external_server")
 		}
 		cacheHandler, err := artifactcache.StartHandler(
 			dir,

internal/app/cmd/cmd.go

@@ -35,8 +35,7 @@ func Execute(ctx context.Context) {
 	}
 	registerCmd.Flags().BoolVar(&regArgs.NoInteractive, "no-interactive", false, "Disable interactive mode")
 	registerCmd.Flags().StringVar(&regArgs.InstanceAddr, "instance", "", "Gitea instance address")
-	registerCmd.Flags().StringVar(&regArgs.Token, "token", "", "Runner token (or set the GITEA_RUNNER_REGISTRATION_TOKEN envvar)")
+	registerCmd.Flags().StringVar(&regArgs.Token, "token", "", "Runner token")
-	registerCmd.Flags().StringVar(&regArgs.TokenFile, "token-file", "", "Path to a file containing the runner token")
 	registerCmd.Flags().StringVar(&regArgs.RunnerName, "name", "", "Runner name")
 	registerCmd.Flags().StringVar(&regArgs.Labels, "labels", "", "Runner tags, comma separated")
 	registerCmd.Flags().BoolVar(&regArgs.Ephemeral, "ephemeral", false, "Configure the runner to be ephemeral and only ever be able to pick a single job (stricter than --once)")
@@ -51,15 +50,11 @@ func Execute(ctx context.Context) {
 		RunE:  runDaemon(ctx, &daemArgs, &configFile),
 	}
 	daemonCmd.Flags().BoolVar(&daemArgs.Once, "once", false, "Run one job then exit")
-	daemonCmd.Flags().StringVar(&daemArgs.Labels, "labels", os.Getenv("GITEA_RUNNER_LABELS"), "Runner labels, comma separated. Overrides the labels of an already registered runner")
 	rootCmd.AddCommand(daemonCmd)
 
 	// ./gitea-runner exec
 	rootCmd.AddCommand(loadExecCmd(ctx))
 
-	// ./gitea-runner bug-report
-	rootCmd.AddCommand(loadBugReportCmd())
-
 	// ./gitea-runner config
 	rootCmd.AddCommand(&cobra.Command{
 		Use:   "generate-config",

internal/app/cmd/daemon.go

@@ -49,7 +49,10 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 			return fmt.Errorf("failed to load registration file: %w", err)
 		}
 
-		lbls := resolveLabels(daemArgs.Labels, cfg.Runner.Labels, reg.Labels)
+		lbls := reg.Labels
+		if len(cfg.Runner.Labels) > 0 {
+			lbls = cfg.Runner.Labels
+		}
 
 		ls := labels.Labels{}
 		for _, l := range lbls {
@@ -64,14 +67,6 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 			log.Warn("no labels configured, runner may not be able to pick up jobs")
 		}
 
-		// Before the first Docker API call: the standard library resolves the proxy
-		// environment once. Ungated because host labels still reach the daemon.
-		if dockerSocketPath, err := getDockerSocketPath(cfg.Container.DockerHost); err == nil {
-			run.BypassProxyForDockerHost(dockerSocketPath)
-		} else {
-			log.Debugf("cannot resolve the docker socket path, so Docker API calls are not exempted from the proxy: %v", err)
-		}
-
 		if ls.RequireDocker() || cfg.Container.RequireDocker {
 			// Wait for dockerd be ready
 			if timeout := cfg.Container.DockerTimeout; timeout > 0 {
@@ -109,7 +104,6 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 			}
 			// if dockerSocketPath passes the check, override DOCKER_HOST with dockerSocketPath
 			os.Setenv("DOCKER_HOST", dockerSocketPath)
-			run.WarnIfDaemonHasNoProxy(ctx)
 			// empty cfg.Container.DockerHost means runner need to find an available docker host automatically
 			// and assign the path to cfg.Container.DockerHost
 			if cfg.Container.DockerHost == "" {
@@ -156,19 +150,17 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 		}
 		runner.SetCapabilitiesFromDeclare(resp)
 
-		poller := poll.New(cfg, cli, runner)
-
 		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, func() (bool, string) {
+			metrics.StartServer(ctx, cfg.Metrics.Addr)
-				return poller.Ready(cfg.Metrics.ReadinessGrace)
-			})
 		}
 
+		poller := poll.New(cfg, cli, runner)
+
 		if daemArgs.Once || reg.Ephemeral {
 			done := make(chan struct{})
 			go func() {
@@ -184,12 +176,7 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 		} else {
 			go poller.Poll()
 
-			// Stop either on an external cancellation or when the poller shuts
+			<-ctx.Done()
-			// itself down (e.g. after the runner has been unregistered).
-			select {
-			case <-ctx.Done():
-			case <-poller.Done():
-			}
 		}
 
 		log.Infof("runner: %s shutdown initiated, waiting %s for running jobs to complete before shutting down", resp.Msg.Runner.Name, cfg.Runner.ShutdownTimeout)
@@ -202,39 +189,12 @@ func runDaemon(ctx context.Context, daemArgs *daemonArgs, configFile *string) fu
 			log.Warnf("runner: %s cancelled in progress jobs during shutdown", resp.Msg.Runner.Name)
 		}
 
-		if poller.Unregistered() {
-			return errors.New("runner is no longer registered with the server; please register it again")
-		}
-
 		return nil
 	}
 }
 
 type daemonArgs struct {
-	Once   bool
+	Once bool
-	Labels string
-}
-
-// resolveLabels picks the labels to run with: --labels/GITEA_RUNNER_LABELS > config > .runner.
-// The flag lets a registered runner change its labels without deleting the .runner file.
-func resolveLabels(argLabels string, cfgLabels, regLabels []string) []string {
-	if lbls := splitLabels(argLabels); len(lbls) > 0 {
-		return lbls
-	}
-	if len(cfgLabels) > 0 {
-		return cfgLabels
-	}
-	return regLabels
-}
-
-func splitLabels(s string) []string {
-	var lbls []string
-	for l := range strings.SplitSeq(s, ",") {
-		if l = strings.TrimSpace(l); l != "" {
-			lbls = append(lbls, l)
-		}
-	}
-	return lbls
 }
 
 // initLogging setup the global logrus logger.

internal/app/cmd/daemon_test.go

@@ -12,32 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestResolveLabels(t *testing.T) {
-	var (
-		cfgLabels = []string{"cfg:host"}
-		regLabels = []string{"reg:host"}
-	)
-
-	tests := []struct {
-		name string
-		arg  string
-		cfg  []string
-		reg  []string
-		want []string
-	}{
-		{"flag wins", "flag:host,other", cfgLabels, regLabels, []string{"flag:host", "other"}},
-		{"config wins over registration", "", cfgLabels, regLabels, cfgLabels},
-		{"registration is the fallback", "", nil, regLabels, regLabels},
-		{"blank flag is ignored", " , ", cfgLabels, regLabels, cfgLabels},
-		{"nothing configured", "", nil, nil, nil},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			require.Equal(t, tt.want, resolveLabels(tt.arg, tt.cfg, tt.reg))
-		})
-	}
-}
-
 func TestGetDockerSocketPathUsesConfigAndEnvironment(t *testing.T) {
 	got, err := getDockerSocketPath("tcp://docker.example:2376")
 	require.NoError(t, err)

internal/app/cmd/exec.go

@@ -22,7 +22,6 @@ import (
 	"gitea.com/gitea/runner/act/common"
 	"gitea.com/gitea/runner/act/model"
 	"gitea.com/gitea/runner/act/runner"
-	"gitea.com/gitea/runner/internal/app/run"
 
 	"github.com/joho/godotenv"
 	"github.com/moby/moby/api/types/container"
@@ -35,7 +34,6 @@ type executeArgs struct {
 	runList               bool
 	job                   string
 	event                 string
-	eventpath             string
 	workdir               string
 	workflowsPath         string
 	noWorkflowRecurse     bool
@@ -416,11 +414,6 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 		}
 		handler.RegisterJob(actionsRuntimeToken, "__local/__exec")
 
-		// no service aliases: exec builds one config for the whole plan
-		run.BypassProxyForDockerHost(os.Getenv("DOCKER_HOST"))
-		proxyEnv := run.JobProxyEnv(env, env["ACTIONS_CACHE_URL"], nil)
-		maps.Copy(env, proxyEnv)
-
 		// run the plan
 		config := &runner.Config{
 			Workdir:               execArgs.Workdir(),
@@ -431,7 +424,6 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 			LogOutput:             true,
 			JSONLogger:            execArgs.jsonLogger,
 			Env:                   env,
-			ProxyEnv:              proxyEnv,
 			Vars:                  execArgs.LoadVars(),
 			Secrets:               execArgs.LoadSecrets(),
 			InsecureSecrets:       execArgs.insecureSecrets,
@@ -449,7 +441,6 @@ func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command
 			ArtifactServerPort:    execArgs.artifactServerPort,
 			ArtifactServerAddr:    execArgs.artifactServerAddr,
 			NoSkipCheckout:        execArgs.noSkipCheckout,
-			EventPath:             execArgs.resolve(execArgs.eventpath),
 			// PresetGitHubContext:   preset,
 			// EventJSON:             string(eventJSON),
 			ContainerNamePrefix:               "GITEA-ACTIONS-TASK-" + eventName,
@@ -505,9 +496,8 @@ func loadExecCmd(ctx context.Context) *cobra.Command {
 	}
 
 	execCmd.Flags().BoolVarP(&execArg.runList, "list", "l", false, "list workflows")
-	execCmd.Flags().StringVarP(&execArg.job, "job", "j", "", "run a specific job ID; when several workflow files define that job, also pass --workflows/-W to select the file")
+	execCmd.Flags().StringVarP(&execArg.job, "job", "j", "", "run a specific job ID")
 	execCmd.Flags().StringVarP(&execArg.event, "event", "E", "", "run a event name")
-	execCmd.Flags().StringVarP(&execArg.eventpath, "eventpath", "e", "", "path to a JSON event payload file exposed as the event that triggered the workflow")
 	execCmd.PersistentFlags().StringVarP(&execArg.workflowsPath, "workflows", "W", "./.gitea/workflows/", "path to workflow file(s)")
 	execCmd.PersistentFlags().StringVarP(&execArg.workdir, "directory", "C", ".", "working directory")
 	execCmd.PersistentFlags().BoolVarP(&execArg.noWorkflowRecurse, "no-recurse", "", false, "Flag to disable running workflows from subdirectories of specified path in '--workflows'/'-W' flag")

internal/app/cmd/register.go

@@ -75,7 +75,6 @@ type registerArgs struct {
 	NoInteractive bool
 	InstanceAddr  string
 	Token         string
-	TokenFile     string
 	RunnerName    string
 	Labels        string
 	Ephemeral     bool
@@ -94,8 +93,6 @@ const (
 	StageExit
 )
 
-const registerTokenEnvVar = "GITEA_RUNNER_REGISTRATION_TOKEN"
-
 var defaultLabels = []string{
 	"ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest",
 	"ubuntu-24.04:docker://docker.gitea.com/runner-images:ubuntu-24.04",
@@ -210,27 +207,10 @@ func (r *registerInputs) assignToNext(stage registerStage, value string, cfg *co
 	return StageUnknown
 }
 
-func initInputs(regArgs *registerArgs) (*registerInputs, error) {
+func initInputs(regArgs *registerArgs) *registerInputs {
-	var token string
-	switch {
-	case regArgs.TokenFile != "":
-		tokenBytes, err := os.ReadFile(regArgs.TokenFile)
-		if err != nil {
-			return nil, fmt.Errorf("cannot read the token file: %s, %v", regArgs.TokenFile, err)
-		}
-		token = string(tokenBytes)
-	case regArgs.Token != "":
-		token = regArgs.Token
-	default:
-		envToken, ok := os.LookupEnv(registerTokenEnvVar)
-		if !ok || envToken == "" {
-			return nil, fmt.Errorf("missing token, token-file argument, or %s environment variable", registerTokenEnvVar)
-		}
-		token = envToken
-	}
 	inputs := &registerInputs{
 		InstanceAddr: regArgs.InstanceAddr,
-		Token:        token,
+		Token:        regArgs.Token,
 		RunnerName:   regArgs.RunnerName,
 		Ephemeral:    regArgs.Ephemeral,
 	}
@@ -239,7 +219,7 @@ func initInputs(regArgs *registerArgs) (*registerInputs, error) {
 	if regArgs.Labels != "" {
 		inputs.Labels = strings.Split(regArgs.Labels, ",")
 	}
-	return inputs, nil
+	return inputs
 }
 
 func registerInteractive(ctx context.Context, configFile string, regArgs *registerArgs) error {
@@ -255,10 +235,7 @@ func registerInteractive(ctx context.Context, configFile string, regArgs *regist
 	if f, err := os.Stat(cfg.Runner.File); err == nil && !f.IsDir() {
 		stage = StageOverwriteLocalConfig
 	}
-	inputs, err := initInputs(regArgs)
+	inputs := initInputs(regArgs)
-	if err != nil {
-		return err
-	}
 
 	for {
 		cmdString := inputs.stageValue(stage)
@@ -315,10 +292,7 @@ func registerNoInteractive(ctx context.Context, configFile string, regArgs *regi
 	if err != nil {
 		return err
 	}
-	inputs, err := initInputs(regArgs)
+	inputs := initInputs(regArgs)
-	if err != nil {
-		return err
-	}
 	// specify labels in config file.
 	if len(cfg.Runner.Labels) > 0 {
 		if regArgs.Labels != "" {
@@ -387,10 +361,7 @@ func doRegister(ctx context.Context, cfg *config.Config, inputs *registerInputs)
 
 	ls := make([]string, len(reg.Labels))
 	for i, v := range reg.Labels {
-		l, err := labels.Parse(v)
+		l, _ := labels.Parse(v)
-		if err != nil {
-			return fmt.Errorf("failed to parse label %q: %w", v, err)
-		}
 		ls[i] = l.Name
 	}
 	// register new runner.

internal/app/cmd/register_test.go

@@ -15,11 +15,11 @@ import (
 
 func TestRegisterNonInteractiveReturnsLabelValidationError(t *testing.T) {
 	err := registerNoInteractive(t.Context(), "", &registerArgs{
-		Labels:       "ubuntu:host,,broken",
+		Labels:       "label:invalid",
 		Token:        "token",
 		InstanceAddr: "http://localhost:3000",
 	})
-	assert.ErrorContains(t, err, "empty label")
+	assert.Error(t, err, "unsupported schema: invalid")
 }
 
 func TestRegisterInputsValidate(t *testing.T) {
@@ -40,8 +40,8 @@ func TestRegisterInputsValidate(t *testing.T) {
 		},
 		{
 			name:    "invalid label",
-			inputs:  registerInputs{InstanceAddr: "http://localhost:3000", Token: "token", Labels: []string{""}},
+			inputs:  registerInputs{InstanceAddr: "http://localhost:3000", Token: "token", Labels: []string{"ubuntu:vm:bad"}},
-			wantErr: "empty label",
+			wantErr: "unsupported schema: vm",
 		},
 		{
 			name:   "valid",
@@ -62,9 +62,7 @@ func TestRegisterInputsValidate(t *testing.T) {
 
 func TestValidateLabels(t *testing.T) {
 	require.NoError(t, validateLabels([]string{"ubuntu:host", "ubuntu:docker://node:18"}))
-	// a colon that is not a supported schema is part of the label name
+	require.Error(t, validateLabels([]string{"ubuntu:host", "ubuntu:vm:bad"}))
-	require.NoError(t, validateLabels([]string{"pool:e57e18d4-10d4-406f-93bf-60f127221bdd"}))
-	require.Error(t, validateLabels([]string{"ubuntu:host", ""}))
 }
 
 func TestRegisterInputsStageValue(t *testing.T) {
@@ -108,10 +106,11 @@ func TestRegisterInputsAssignToNext(t *testing.T) {
 
 	t.Run("labels from config skip the labels stage", func(t *testing.T) {
 		cfg := &config.Config{}
-		cfg.Runner.Labels = []string{"ubuntu:host", "", "pool:e57e18d4"}
+		cfg.Runner.Labels = []string{"ubuntu:host", "ubuntu:vm:bad"}
 		inputs := &registerInputs{}
 		require.Equal(t, StageWaitingForRegistration, inputs.assignToNext(StageInputRunnerName, "runner", cfg))
-		require.Equal(t, []string{"ubuntu:host", "pool:e57e18d4"}, inputs.Labels)
+		// only the valid label survives
+		require.Equal(t, []string{"ubuntu:host"}, inputs.Labels)
 	})
 
 	t.Run("blank labels input uses defaults", func(t *testing.T) {
@@ -122,16 +121,10 @@ func TestRegisterInputsAssignToNext(t *testing.T) {
 
 	t.Run("invalid labels input loops back", func(t *testing.T) {
 		inputs := &registerInputs{}
-		require.Equal(t, StageInputLabels, inputs.assignToNext(StageInputLabels, "ubuntu:host,,bad", emptyCfg))
+		require.Equal(t, StageInputLabels, inputs.assignToNext(StageInputLabels, "ubuntu:vm:bad", emptyCfg))
 		require.Nil(t, inputs.Labels)
 	})
 
-	t.Run("labels containing a colon are accepted", func(t *testing.T) {
-		inputs := &registerInputs{}
-		require.Equal(t, StageWaitingForRegistration, inputs.assignToNext(StageInputLabels, "pool:e57e18d4,ubuntu:host", emptyCfg))
-		require.Equal(t, []string{"pool:e57e18d4", "ubuntu:host"}, inputs.Labels)
-	})
-
 	t.Run("overwrite local config", func(t *testing.T) {
 		inputs := &registerInputs{}
 		require.Equal(t, StageInputInstance, inputs.assignToNext(StageOverwriteLocalConfig, "Y", emptyCfg))
@@ -146,103 +139,18 @@ func TestRegisterInputsAssignToNext(t *testing.T) {
 }
 
 func TestInitInputs(t *testing.T) {
-	t.Run("missing token", func(t *testing.T) {
+	inputs := initInputs(&registerArgs{
-		_, err := initInputs(&registerArgs{
+		InstanceAddr: "http://localhost:3000",
-			InstanceAddr: "http://localhost:3000",
+		Token:        "token",
-			RunnerName:   "runner",
+		RunnerName:   "runner",
-			Ephemeral:    true,
+		Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
+		Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.EqualError(t, err, "missing token, token-file argument, or GITEA_RUNNER_REGISTRATION_TOKEN environment variable")
 	})
+	require.Equal(t, "http://localhost:3000", inputs.InstanceAddr)
+	require.Equal(t, "token", inputs.Token)
+	require.Equal(t, "runner", inputs.RunnerName)
+	require.True(t, inputs.Ephemeral)
+	require.Equal(t, []string{"ubuntu:host ", " ubuntu:docker://node:18"}, inputs.Labels)
 
-	t.Run("empty token", func(t *testing.T) {
+	require.Nil(t, initInputs(&registerArgs{Labels: "  "}).Labels)
-		t.Setenv(registerTokenEnvVar, "")
-		_, err := initInputs(&registerArgs{
-			InstanceAddr: "http://localhost:3000",
-			Token:        "",
-			TokenFile:    "",
-			RunnerName:   "runner",
-			Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.EqualError(t, err, "missing token, token-file argument, or GITEA_RUNNER_REGISTRATION_TOKEN environment variable")
-	})
-
-	t.Run("invalid token file", func(t *testing.T) {
-		t.Setenv(registerTokenEnvVar, "from-env")
-		_, err := initInputs(&registerArgs{
-			InstanceAddr: "http://localhost:3000",
-			TokenFile:    "/tmp/nonexistent",
-			RunnerName:   "runner",
-			Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.EqualError(t, err, "cannot read the token file: /tmp/nonexistent, open /tmp/nonexistent: no such file or directory")
-	})
-
-	t.Run("valid token", func(t *testing.T) {
-		t.Setenv(registerTokenEnvVar, "from-env")
-		inputs, err := initInputs(&registerArgs{
-			InstanceAddr: "http://localhost:3000",
-			Token:        "from-plain-arg",
-			RunnerName:   "runner",
-			Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.NoError(t, err)
-		require.Equal(t, "http://localhost:3000", inputs.InstanceAddr)
-		require.Equal(t, "from-plain-arg", inputs.Token)
-		require.Equal(t, "runner", inputs.RunnerName)
-		require.True(t, inputs.Ephemeral)
-		require.Equal(t, []string{"ubuntu:host ", " ubuntu:docker://node:18"}, inputs.Labels)
-	})
-
-	t.Run("valid token file", func(t *testing.T) {
-		t.Setenv(registerTokenEnvVar, "from-env")
-		tokenFile, createErr := os.CreateTemp(t.TempDir(), "from-file")
-		require.NoError(t, createErr)
-		defer tokenFile.Close()
-		_, writeErr := tokenFile.WriteString("from-file")
-		require.NoError(t, writeErr)
-		_ = tokenFile.Sync()
-
-		inputs, err := initInputs(&registerArgs{
-			InstanceAddr: "http://localhost:3000",
-			TokenFile:    tokenFile.Name(),
-			RunnerName:   "runner",
-			Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.NoError(t, err)
-		require.Equal(t, "http://localhost:3000", inputs.InstanceAddr)
-		require.Equal(t, "from-file", inputs.Token)
-		require.Equal(t, "runner", inputs.RunnerName)
-		require.True(t, inputs.Ephemeral)
-		require.Equal(t, []string{"ubuntu:host ", " ubuntu:docker://node:18"}, inputs.Labels)
-	})
-
-	t.Run("token from environment variable", func(t *testing.T) {
-		t.Setenv(registerTokenEnvVar, "from-env")
-		inputs, err := initInputs(&registerArgs{
-			InstanceAddr: "http://localhost:3000",
-			RunnerName:   "runner",
-			Ephemeral:    true,
-			Labels:       " ubuntu:host , ubuntu:docker://node:18 ",
-		})
-		require.NoError(t, err)
-		require.Equal(t, "http://localhost:3000", inputs.InstanceAddr)
-		require.Equal(t, "from-env", inputs.Token)
-		require.Equal(t, "runner", inputs.RunnerName)
-		require.True(t, inputs.Ephemeral)
-		require.Equal(t, []string{"ubuntu:host ", " ubuntu:docker://node:18"}, inputs.Labels)
-	})
-
-	t.Run("empty labels", func(t *testing.T) {
-		inputs, _ := initInputs(&registerArgs{
-			Token:  "from-plain-arg",
-			Labels: "  ",
-		})
-		require.Nil(t, inputs.Labels)
-	})
 }

internal/app/poll/poller.go

@@ -32,12 +32,6 @@ type IdleRunner interface {
 	OnIdle(ctx context.Context)
 }
 
-// AvailabilityRunner can temporarily pause task fetching for local resource
-// conditions such as low disk space without changing server-side scheduling.
-type AvailabilityRunner interface {
-	CanAcceptTask(ctx context.Context) (bool, string)
-}
-
 type Poller struct {
 	client       client.Client
 	runner       TaskRunner
@@ -51,15 +45,6 @@ type Poller struct {
 	shutdownJobs context.CancelFunc
 
 	done chan struct{}
-
-	// unregistered is set when the server rejects the runner with an
-	// Unauthenticated response, meaning the runner is no longer registered.
-	unregistered       atomic.Bool
-	lastHealthyPoll    atomic.Int64
-	lastPollFailed     atomic.Bool
-	availabilityMu     sync.Mutex
-	availabilityReady  bool
-	availabilityReason string
 }
 
 // workerState holds the single poller's backoff state. Consecutive empty or
@@ -81,7 +66,7 @@ func New(cfg *config.Config, client client.Client, runner TaskRunner) *Poller {
 
 	done := make(chan struct{})
 
-	p := &Poller{
+	return &Poller{
 		client: client,
 		runner: runner,
 		cfg:    cfg,
@@ -94,10 +79,6 @@ func New(cfg *config.Config, client client.Client, runner TaskRunner) *Poller {
 
 		done: done,
 	}
-	p.lastHealthyPoll.Store(time.Now().UnixNano())
-	p.availabilityReady = true
-	p.availabilityReason = "ok"
-	return p
 }
 
 func (p *Poller) Poll() {
@@ -117,17 +98,6 @@ func (p *Poller) Poll() {
 			return
 		}
 
-		ready, reason := p.localAvailability(p.pollingCtx)
-		p.reportAvailability(ready, reason)
-		if !ready {
-			p.runIdleMaintenance()
-			<-sem
-			if !p.waitBackoff(s) {
-				return
-			}
-			continue
-		}
-
 		task, ok := p.fetchTask(p.pollingCtx, s)
 		if !ok {
 			p.runIdleMaintenance()
@@ -153,15 +123,6 @@ func (p *Poller) PollOnce() {
 	defer close(p.done)
 	s := &workerState{}
 	for {
-		ready, reason := p.localAvailability(p.pollingCtx)
-		p.reportAvailability(ready, reason)
-		if !ready {
-			p.runIdleMaintenance()
-			if !p.waitBackoff(s) {
-				return
-			}
-			continue
-		}
 		task, ok := p.fetchTask(p.pollingCtx, s)
 		if !ok {
 			p.runIdleMaintenance()
@@ -176,61 +137,6 @@ func (p *Poller) PollOnce() {
 	}
 }
 
-// Done returns a channel that is closed once polling has fully stopped,
-// allowing callers to react when the poller shuts itself down (e.g. after the
-// runner has been unregistered) rather than only on an external cancellation.
-func (p *Poller) Done() <-chan struct{} {
-	return p.done
-}
-
-// Unregistered reports whether polling stopped because the server rejected the
-// runner as unregistered (an Unauthenticated response).
-func (p *Poller) Unregistered() bool {
-	return p.unregistered.Load()
-}
-
-// Ready reports whether the daemon can currently communicate with Gitea and
-// accept work, reusing the availability the poll loop last observed rather than
-// re-running the check. Transient transport failures are tolerated for grace.
-func (p *Poller) Ready(grace time.Duration) (bool, string) {
-	if p.unregistered.Load() {
-		return false, "runner is no longer registered"
-	}
-	p.availabilityMu.Lock()
-	ready, reason := p.availabilityReady, p.availabilityReason
-	p.availabilityMu.Unlock()
-	if !ready {
-		return false, reason
-	}
-	if !p.lastPollFailed.Load() {
-		return true, "ok"
-	}
-	if time.Since(time.Unix(0, p.lastHealthyPoll.Load())) <= grace {
-		return true, "polling errors within grace period"
-	}
-	return false, "unable to poll Gitea"
-}
-
-func (p *Poller) localAvailability(ctx context.Context) (bool, string) {
-	if available, ok := p.runner.(AvailabilityRunner); ok {
-		return available.CanAcceptTask(ctx)
-	}
-	return true, "ok"
-}
-
-func (p *Poller) reportAvailability(ready bool, reason string) {
-	p.availabilityMu.Lock()
-	defer p.availabilityMu.Unlock()
-	switch {
-	case !ready && p.availabilityReady:
-		log.Warnf("runner temporarily unavailable: %s", reason)
-	case ready && !p.availabilityReady:
-		log.Info("runner local health recovered, resuming task polling")
-	}
-	p.availabilityReady = ready
-	p.availabilityReason = reason
-}
-
 func (p *Poller) runIdleMaintenance() {
 	if idleRunner, ok := p.runner.(IdleRunner); ok {
 		idleRunner.OnIdle(p.jobsCtx)
@@ -350,7 +256,6 @@ func (p *Poller) fetchTask(ctx context.Context, s *workerState) (*runnerv1.Task,
 	// 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) {
-		p.markHealthyPoll()
 		s.consecutiveEmpty++
 		s.consecutiveErrors = 0 // timeout is a healthy idle response
 		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultEmpty).Inc()
@@ -359,23 +264,12 @@ func (p *Poller) fetchTask(ctx context.Context, s *workerState) (*runnerv1.Task,
 	metrics.PollFetchDuration.Observe(time.Since(start).Seconds())
 
 	if err != nil {
-		// An Unauthenticated response means the server no longer knows this
-		// runner (e.g. it was deleted). Retrying forever is pointless, so stop
-		// polling and let the daemon exit with an error instead of spinning.
-		if connect.CodeOf(err) == connect.CodeUnauthenticated {
-			log.WithError(err).Error("server rejected the runner as unregistered, stopping poller")
-			p.unregistered.Store(true)
-			p.shutdownPolling()
-			return nil, false
-		}
 		log.WithError(err).Error("failed to fetch task")
-		p.lastPollFailed.Store(true)
 		s.consecutiveErrors++
 		metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultError).Inc()
 		metrics.ClientErrors.WithLabelValues(metrics.LabelMethodFetchTask).Inc()
 		return nil, false
 	}
-	p.markHealthyPoll()
 
 	// Successful response — reset error counter.
 	s.consecutiveErrors = 0
@@ -402,8 +296,3 @@ func (p *Poller) fetchTask(ctx context.Context, s *workerState) (*runnerv1.Task,
 	metrics.PollFetchTotal.WithLabelValues(metrics.LabelResultTask).Inc()
 	return resp.Msg.Task, true
 }
-
-func (p *Poller) markHealthyPoll() {
-	p.lastHealthyPoll.Store(time.Now().UnixNano())
-	p.lastPollFailed.Store(false)
-}

internal/app/poll/poller_test.go

@@ -78,35 +78,6 @@ func TestPoller_FetchErrorIncrementsErrorsOnly(t *testing.T) {
 	assert.Equal(t, int64(0), s.consecutiveEmpty)
 }
 
-// TestPoller_FetchUnauthenticatedStopsPolling verifies that an Unauthenticated
-// response marks the runner as unregistered and cancels the polling context so
-// the daemon can exit instead of retrying forever.
-func TestPoller_FetchUnauthenticatedStopsPolling(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, connect_go.NewError(connect_go.CodeUnauthenticated, errors.New("unregistered runner"))
-		},
-	)
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	p := New(cfg, client, nil)
-
-	s := &workerState{}
-	_, ok := p.fetchTask(context.Background(), s)
-	require.False(t, ok)
-
-	assert.True(t, p.Unregistered(), "runner should be marked unregistered")
-	assert.Equal(t, int64(0), s.consecutiveErrors, "unauthenticated must not drive error backoff")
-
-	select {
-	case <-p.pollingCtx.Done():
-	default:
-		t.Fatal("expected polling context to be cancelled after an Unauthenticated response")
-	}
-}
-
 // TestPoller_CalculateInterval verifies the exponential backoff math is
 // correctly driven by the workerState counters.
 func TestPoller_CalculateInterval(t *testing.T) {
@@ -159,81 +130,6 @@ type idleAwareRunner struct {
 	idleCalls atomic.Int64
 }
 
-type availabilityRunner struct {
-	mockRunner
-	ready  atomic.Bool
-	reason string
-}
-
-func (r *availabilityRunner) CanAcceptTask(_ context.Context) (bool, string) {
-	if r.ready.Load() {
-		return true, "ok"
-	}
-	return false, r.reason
-}
-
-func TestPollerReady(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	poller := New(cfg, nil, &availabilityRunner{})
-
-	// /readyz reuses the availability the poll loop last recorded.
-	ready, reason := poller.Ready(time.Second)
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-
-	poller.reportAvailability(false, "low disk space")
-	ready, reason = poller.Ready(time.Second)
-	assert.False(t, ready)
-	assert.Equal(t, "low disk space", reason)
-
-	poller.reportAvailability(true, "ok")
-	poller.lastPollFailed.Store(true)
-	poller.lastHealthyPoll.Store(time.Now().UnixNano())
-	ready, _ = poller.Ready(time.Second)
-	assert.True(t, ready, "transient polling errors should remain ready during grace")
-
-	poller.lastHealthyPoll.Store(time.Now().Add(-2 * time.Second).UnixNano())
-	ready, reason = poller.Ready(time.Second)
-	assert.False(t, ready)
-	assert.Equal(t, "unable to poll Gitea", reason)
-
-	poller.unregistered.Store(true)
-	ready, reason = poller.Ready(time.Second)
-	assert.False(t, ready)
-	assert.Equal(t, "runner is no longer registered", reason)
-}
-
-func TestPollerPausesAndResumesForLocalAvailability(t *testing.T) {
-	var fetches atomic.Int64
-	cli := mocks.NewClient(t)
-	cli.On("FetchTask", mock.Anything, mock.Anything).Maybe().Run(func(mock.Arguments) {
-		fetches.Add(1)
-	}).Return(connect_go.NewResponse(&runnerv1.FetchTaskResponse{}), nil)
-
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.Runner.FetchInterval = 10 * time.Millisecond
-	cfg.Runner.FetchIntervalMax = 10 * time.Millisecond
-	runner := &availabilityRunner{reason: "low disk space"}
-	poller := New(cfg, cli, runner)
-
-	var wg sync.WaitGroup
-	wg.Go(poller.Poll)
-	time.Sleep(40 * time.Millisecond)
-	assert.Zero(t, fetches.Load(), "an unavailable runner must not fetch a task")
-
-	runner.ready.Store(true)
-	require.Eventually(t, func() bool {
-		return fetches.Load() > 0
-	}, time.Second, 10*time.Millisecond, "polling should resume after local recovery")
-
-	shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-	require.NoError(t, poller.Shutdown(shutdownCtx))
-	wg.Wait()
-}
-
 func (m *mockRunner) Run(ctx context.Context, _ *runnerv1.Task) error {
 	atomicMax(&m.maxConcurrent, m.running.Add(1))
 	select {

internal/app/run/disk_other.go

@@ -1,12 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows
-
-package run
-
-import "fmt"
-
-func freeDiskBytes(path string) (uint64, error) {
-	return 0, fmt.Errorf("free disk space checks are not supported for %s", path)
-}

internal/app/run/disk_test.go

@@ -1,53 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"testing"
-
-	"gitea.com/gitea/runner/internal/pkg/config"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCanAcceptTaskDiskGuard(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.Host.WorkdirParent = t.TempDir()
-	cfg.HealthCheck.Enabled = true
-	r := &Runner{cfg: cfg}
-
-	ready, _ := r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-
-	cfg.HealthCheck.MinFreeDiskSpaceMB = 1 << 40
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.False(t, ready)
-	assert.Contains(t, reason, "low disk space")
-}
-
-func TestDiskCheckDeferredWhileJobRuns(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.HealthCheck.Enabled = true
-	cfg.HealthCheck.MinFreeDiskSpaceMB = 1
-	cfg.Host.WorkdirParent = t.TempDir()
-	r := &Runner{cfg: cfg}
-
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-
-	cfg.HealthCheck.MinFreeDiskSpaceMB = 1 << 40
-	r.runningCount.Store(1)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.True(t, ready, "the disk check must not run while a job is active")
-	assert.Equal(t, "ok", reason)
-
-	r.runningCount.Store(0)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.False(t, ready)
-	assert.Contains(t, reason, "low disk space")
-}

internal/app/run/disk_unix.go

@@ -1,16 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
-
-package run
-
-import "golang.org/x/sys/unix"
-
-func freeDiskBytes(path string) (uint64, error) {
-	var stat unix.Statfs_t
-	if err := unix.Statfs(path, &stat); err != nil {
-		return 0, err
-	}
-	return uint64(stat.Bavail) * uint64(stat.Bsize), nil //nolint:unconvert // Bavail/Bsize signedness differs by platform
-}

internal/app/run/disk_windows.go

@@ -1,20 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build windows
-
-package run
-
-import "golang.org/x/sys/windows"
-
-func freeDiskBytes(path string) (uint64, error) {
-	pathPtr, err := windows.UTF16PtrFromString(path)
-	if err != nil {
-		return 0, err
-	}
-	var available uint64
-	if err := windows.GetDiskFreeSpaceEx(pathPtr, &available, nil, nil); err != nil {
-		return 0, err
-	}
-	return available, nil
-}

internal/app/run/health_check.go

@@ -1,106 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"maps"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"gitea.com/gitea/runner/act/common"
-	"gitea.com/gitea/runner/internal/pkg/process"
-)
-
-func (r *Runner) checkConfiguredHealth(ctx context.Context) (bool, string) {
-	script := r.cfg.HealthCheck.Script
-	if script == "" {
-		return true, "ok"
-	}
-
-	now := time.Now()
-	if r.now != nil {
-		now = r.now()
-	}
-	if !r.healthCheckLast.IsZero() && now.Sub(r.healthCheckLast) < r.cfg.HealthCheck.Interval {
-		return r.healthCheckReady, r.healthCheckReason
-	}
-
-	env := processEnvironment()
-	maps.Copy(env, r.cloneEnvs())
-	env["GITEA_RUNNER_HEALTH_CHECK"] = "true"
-	env["GITEA_RUNNER_NAME"] = r.name
-	if r.client != nil {
-		env["GITEA_INSTANCE_URL"] = r.client.Address()
-	}
-	env["GITEA_RUNNER_RUNNING_JOBS"] = strconv.FormatInt(r.RunningCount(), 10)
-
-	runner := r.runHealthCheck
-	if runner == nil {
-		runner = executeHealthCheck
-	}
-	err := runner(ctx, script, r.cfg.HealthCheck.Timeout, env)
-	r.healthCheckLast = now
-	r.healthCheckReady = err == nil
-	if err != nil {
-		r.healthCheckReason = "runner health check failed: " + err.Error()
-	} else {
-		r.healthCheckReason = "ok"
-	}
-	return r.healthCheckReady, r.healthCheckReason
-}
-
-func executeHealthCheck(ctx context.Context, script string, timeout time.Duration, env map[string]string) error {
-	checkCtx, cancel := context.WithTimeout(ctx, timeout)
-	defer cancel()
-	cmd := exec.CommandContext(checkCtx, script)
-	cmd.Env = envListFromMap(env)
-	cmd.SysProcAttr = process.SysProcAttr(script, false)
-	writer := common.NewLineWriter(func(line string) bool {
-		line = strings.TrimRight(line, "\r\n")
-		if line != "" {
-			common.Logger(ctx).Infof("health check: %s", line)
-		}
-		return true
-	})
-	cmd.Stdout = writer
-	cmd.Stderr = writer
-
-	treeKill := process.NewTreeKill(cmd)
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("start: %w", err)
-	}
-	if killer, err := treeKill.Capture(cmd.Process); err == nil {
-		defer killer.Close()
-	}
-	err := cmd.Wait()
-	common.FlushWriter(writer)
-	if errors.Is(checkCtx.Err(), context.DeadlineExceeded) {
-		return fmt.Errorf("timed out after %s", timeout)
-	}
-	if err == nil {
-		return nil
-	}
-	var exitErr *exec.ExitError
-	if errors.As(err, &exitErr) {
-		return fmt.Errorf("exited with code %d", exitErr.ExitCode())
-	}
-	return err
-}
-
-func processEnvironment() map[string]string {
-	environ := os.Environ()
-	env := make(map[string]string, len(environ))
-	for _, value := range environ {
-		if key, item, ok := strings.Cut(value, "="); ok {
-			env[key] = item
-		}
-	}
-	return env
-}

internal/app/run/health_check_test.go

@@ -1,148 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	"gitea.com/gitea/runner/internal/pkg/config"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestConfiguredHealthCheckCachesAndRecovers(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.HealthCheck.Enabled = true
-	cfg.HealthCheck.Script = "/health-check"
-	cfg.HealthCheck.Interval = time.Minute
-	cfg.HealthCheck.Timeout = time.Second
-
-	now := time.Now()
-	calls := 0
-	fail := true
-	r := &Runner{
-		cfg:  cfg,
-		name: "runner-1",
-		now:  func() time.Time { return now },
-		runHealthCheck: func(_ context.Context, script string, timeout time.Duration, env map[string]string) error {
-			calls++
-			assert.Equal(t, "/health-check", script)
-			assert.Equal(t, time.Second, timeout)
-			assert.Equal(t, "true", env["GITEA_RUNNER_HEALTH_CHECK"])
-			assert.Equal(t, "runner-1", env["GITEA_RUNNER_NAME"])
-			if fail {
-				return errors.New("unhealthy")
-			}
-			return nil
-		},
-	}
-
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.False(t, ready)
-	assert.Contains(t, reason, "unhealthy")
-	assert.Equal(t, 1, calls)
-
-	fail = false
-	ready, _ = r.CanAcceptTask(t.Context())
-	assert.False(t, ready, "the failed result should remain cached")
-	assert.Equal(t, 1, calls)
-
-	now = now.Add(time.Minute)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-	assert.Equal(t, 2, calls)
-}
-
-func TestConfiguredHealthCheckDisabled(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.HealthCheck.MinFreeDiskSpaceMB = 1 << 40
-	cfg.HealthCheck.Script = "/must-not-run"
-	r := &Runner{
-		cfg: cfg,
-		runHealthCheck: func(_ context.Context, _ string, _ time.Duration, _ map[string]string) error {
-			t.Fatal("disabled health check executed")
-			return nil
-		},
-	}
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-}
-
-func TestConfiguredHealthCheckDeferredWhileJobRuns(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.HealthCheck.Enabled = true
-	cfg.HealthCheck.Script = "/health-check"
-	cfg.HealthCheck.Interval = time.Minute
-
-	now := time.Now()
-	calls := 0
-	fail := false
-	r := &Runner{
-		cfg: cfg,
-		now: func() time.Time { return now },
-		runHealthCheck: func(_ context.Context, _ string, _ time.Duration, _ map[string]string) error {
-			calls++
-			if fail {
-				return errors.New("unhealthy")
-			}
-			return nil
-		},
-	}
-
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-	assert.Equal(t, 1, calls)
-
-	now = now.Add(time.Minute)
-	fail = true
-	r.runningCount.Store(1)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.True(t, ready, "the last result should be reused while a job runs")
-	assert.Equal(t, "ok", reason)
-	assert.Equal(t, 1, calls)
-
-	r.runningCount.Store(0)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.False(t, ready)
-	assert.Contains(t, reason, "unhealthy")
-	assert.Equal(t, 2, calls)
-}
-
-func TestConfiguredHealthCheckInitialRunDeferredWhileJobRuns(t *testing.T) {
-	cfg, err := config.LoadDefault("")
-	require.NoError(t, err)
-	cfg.HealthCheck.Enabled = true
-	cfg.HealthCheck.Script = "/health-check"
-
-	calls := 0
-	r := &Runner{
-		cfg: cfg,
-		runHealthCheck: func(_ context.Context, _ string, _ time.Duration, _ map[string]string) error {
-			calls++
-			return nil
-		},
-	}
-	r.runningCount.Store(1)
-
-	ready, reason := r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Contains(t, reason, "deferred")
-	assert.Zero(t, calls)
-
-	r.runningCount.Store(0)
-	ready, reason = r.CanAcceptTask(t.Context())
-	assert.True(t, ready)
-	assert.Equal(t, "ok", reason)
-	assert.Equal(t, 1, calls)
-}

internal/app/run/proxy.go

@@ -1,163 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"context"
-	"net/url"
-	"os"
-	"slices"
-	"strings"
-
-	"gitea.com/gitea/runner/act/container"
-
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/net/http/httpproxy"
-)
-
-// proxyFromEnv returns the runner's own proxy configuration, or nil when it has none.
-func proxyFromEnv() *httpproxy.Config {
-	cfg := httpproxy.FromEnvironment()
-	if cfg.HTTPProxy == "" && cfg.HTTPSProxy == "" {
-		return nil
-	}
-	return cfg
-}
-
-// JobProxyEnv returns the proxy variables a job runs with, given what runner.envs already
-// put in jobEnvs. Gitea is deliberately not made direct, so it stays reachable however the
-// runner reaches it.
-func JobProxyEnv(jobEnvs map[string]string, cacheURL string, serviceNames []string) map[string]string {
-	cfg := proxyFromEnv()
-	if cfg == nil {
-		return nil
-	}
-
-	// Go bypasses loopback on its own, curl and most other tools in a job do not.
-	direct := append([]string{"localhost", "127.0.0.1", "::1"}, serviceNames...)
-	direct = append(direct, hostOf(cacheURL))
-
-	proxyEnv := map[string]string{}
-	setPair := func(lower, upper, value string) {
-		if value == "" {
-			return
-		}
-		// Either spelling in runner.envs takes over both, so the pair cannot disagree.
-		if existing, ok := jobEnvs[lower]; ok {
-			value = existing
-		} else if existing, ok := jobEnvs[upper]; ok {
-			value = existing
-		}
-		proxyEnv[lower], proxyEnv[upper] = value, value
-	}
-	setPair("http_proxy", "HTTP_PROXY", cfg.HTTPProxy)
-	setPair("https_proxy", "HTTPS_PROXY", cfg.HTTPSProxy)
-
-	// no_proxy is merged rather than replaced: the hosts above are structural, and an
-	// operator cannot list the cache server's startup-assigned address in advance.
-	noProxy := appendNoProxy(cfg.NoProxy, direct...)
-	for _, name := range []string{"no_proxy", "NO_PROXY"} {
-		if existing, ok := jobEnvs[name]; ok {
-			noProxy = appendNoProxy(existing, strings.Split(noProxy, ",")...)
-			break
-		}
-	}
-	proxyEnv["no_proxy"], proxyEnv["NO_PROXY"] = noProxy, noProxy
-	return proxyEnv
-}
-
-// BypassProxyForDockerHost keeps the runner's Docker API traffic off the proxy: the docker
-// client proxies every transport that is not a unix socket or a named pipe, so a tcp://
-// daemon would be reached through a proxy that cannot route to it.
-//
-// It must run before the first Docker API call, because the standard library resolves the
-// proxy environment once.
-func BypassProxyForDockerHost(dockerHost string) {
-	cfg := proxyFromEnv()
-	if cfg == nil {
-		return
-	}
-	host := hostOf(dockerHost)
-	if host == "" {
-		// A unix socket or named pipe is never proxied.
-		return
-	}
-
-	noProxy := appendNoProxy(cfg.NoProxy, host)
-	for _, name := range []string{"no_proxy", "NO_PROXY"} {
-		if err := os.Setenv(name, noProxy); err != nil {
-			log.Warnf("cannot set %s for the runner process: %v", name, err)
-		}
-	}
-	log.Debugf("docker host %s is reached directly, no_proxy is now %q", host, noProxy)
-}
-
-// WarnIfDaemonHasNoProxy points at the one part the runner cannot set: the docker daemon
-// pulls the images, and a daemon in its own container needs its own proxy.
-func WarnIfDaemonHasNoProxy(ctx context.Context) {
-	if proxyFromEnv() == nil {
-		return
-	}
-	info, err := container.GetHostInfo(ctx)
-	if err != nil {
-		log.Debugf("cannot read the docker daemon's proxy configuration: %v", err)
-		return
-	}
-	if info.HTTPProxy == "" && info.HTTPSProxy == "" {
-		log.Warn("the runner has a proxy but the docker daemon reports none, so image pulls will not use it: https://docs.docker.com/engine/daemon/proxy/")
-	}
-}
-
-// proxyPasswords returns the passwords embedded in the runner's proxy URLs, to mask before
-// a job echoes its environment.
-func proxyPasswords() []string {
-	cfg := proxyFromEnv()
-	if cfg == nil {
-		return nil
-	}
-
-	var passwords []string
-	for _, raw := range []string{cfg.HTTPProxy, cfg.HTTPSProxy} {
-		parsed, err := url.Parse(raw)
-		if err != nil || parsed.User == nil {
-			continue
-		}
-		if password, ok := parsed.User.Password(); ok && password != "" && !slices.Contains(passwords, password) {
-			passwords = append(passwords, password)
-		}
-	}
-	return passwords
-}
-
-// appendNoProxy adds hosts to a no_proxy list, keeping the operator's entries and adding
-// none twice.
-func appendNoProxy(noProxy string, hosts ...string) string {
-	entries := []string{}
-	for entry := range strings.SplitSeq(noProxy, ",") {
-		if entry = strings.TrimSpace(entry); entry != "" {
-			entries = append(entries, entry)
-		}
-	}
-
-	for _, host := range hosts {
-		if host == "" || slices.Contains(entries, host) {
-			continue
-		}
-		entries = append(entries, host)
-	}
-	return strings.Join(entries, ",")
-}
-
-// hostOf returns the host of a URL without its port, the form a no_proxy entry takes. It is
-// empty for anything without a network host, such as a unix socket.
-func hostOf(raw string) string {
-	if raw == "" {
-		return ""
-	}
-	parsed, err := url.Parse(strings.TrimSuffix(raw, "/"))
-	if err != nil || parsed.Hostname() == "" {
-		return ""
-	}
-	return parsed.Hostname()
-}

internal/app/run/proxy_test.go

@@ -1,192 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// clearProxyEnv starts a test from a runner that has no proxy, whatever the developer's own
-// environment looks like.
-func clearProxyEnv(t *testing.T) {
-	t.Helper()
-	for _, name := range []string{"http_proxy", "HTTP_PROXY", "https_proxy", "HTTPS_PROXY", "no_proxy", "NO_PROXY"} {
-		t.Setenv(name, "")
-	}
-}
-
-func TestJobProxyEnv(t *testing.T) {
-	const loopback = "localhost,127.0.0.1,::1"
-	const proxy = "http://proxy:3128"
-
-	for _, tc := range []struct {
-		name     string
-		runner   map[string]string // the runner process environment
-		envs     map[string]string // what runner.envs already put in the job
-		cacheURL string
-		services []string
-		want     map[string]string
-	}{
-		{
-			// The guarantee that makes this safe to ship: a runner without a proxy gives its
-			// jobs nothing at all.
-			name:     "runner has no proxy",
-			cacheURL: "http://cache.local:8088/",
-		},
-		{
-			name:   "a lone no_proxy is not a proxy",
-			runner: map[string]string{"no_proxy": "example.com"},
-		},
-		{
-			name:   "both spellings of every variable",
-			runner: map[string]string{"http_proxy": proxy, "https_proxy": proxy},
-			want: map[string]string{
-				"http_proxy": proxy, "HTTP_PROXY": proxy,
-				"https_proxy": proxy, "HTTPS_PROXY": proxy,
-				"no_proxy": loopback, "NO_PROXY": loopback,
-			},
-		},
-		{
-			name:   "a variable the runner does not have is omitted",
-			runner: map[string]string{"https_proxy": proxy},
-			want: map[string]string{
-				"https_proxy": proxy, "HTTPS_PROXY": proxy,
-				"no_proxy": loopback, "NO_PROXY": loopback,
-			},
-		},
-		{
-			// The cache server and the service containers are on the local network; Gitea is
-			// not added and keeps being reached through the proxy.
-			name:     "hosts the job must reach directly",
-			runner:   map[string]string{"http_proxy": proxy, "no_proxy": "internal.example"},
-			cacheURL: "http://192.168.1.10:34567/",
-			services: []string{"postgres", "redis"},
-			want: map[string]string{
-				"http_proxy": proxy, "HTTP_PROXY": proxy,
-				"no_proxy": "internal.example," + loopback + ",postgres,redis,192.168.1.10",
-				"NO_PROXY": "internal.example," + loopback + ",postgres,redis,192.168.1.10",
-			},
-		},
-		{
-			name:   "runner.envs wins, for both spellings",
-			runner: map[string]string{"http_proxy": "http://from-env:3128"},
-			envs:   map[string]string{"http_proxy": "http://from-config:3128"},
-			want: map[string]string{
-				"http_proxy": "http://from-config:3128", "HTTP_PROXY": "http://from-config:3128",
-				"no_proxy": loopback, "NO_PROXY": loopback,
-			},
-		},
-		{
-			name:   "runner.envs wins through the upper case spelling too",
-			runner: map[string]string{"http_proxy": "http://from-env:3128"},
-			envs:   map[string]string{"HTTP_PROXY": "http://from-config:3128"},
-			want: map[string]string{
-				"http_proxy": "http://from-config:3128", "HTTP_PROXY": "http://from-config:3128",
-				"no_proxy": loopback, "NO_PROXY": loopback,
-			},
-		},
-		{
-			// A runner.envs no_proxy adds to the hosts that must stay direct rather than
-			// replacing them, which would send cache traffic through the proxy.
-			name:     "runner.envs no_proxy is merged, not substituted",
-			runner:   map[string]string{"http_proxy": proxy},
-			envs:     map[string]string{"no_proxy": "operator.example"},
-			cacheURL: "http://192.168.1.10:34567/",
-			want: map[string]string{
-				"http_proxy": proxy, "HTTP_PROXY": proxy,
-				"no_proxy": "operator.example," + loopback + ",192.168.1.10",
-				"NO_PROXY": "operator.example," + loopback + ",192.168.1.10",
-			},
-		},
-		{
-			name:     "runner.envs NO_PROXY is merged through the upper case spelling too",
-			runner:   map[string]string{"http_proxy": proxy},
-			envs:     map[string]string{"NO_PROXY": "operator.example"},
-			cacheURL: "http://192.168.1.10:34567/",
-			want: map[string]string{
-				"http_proxy": proxy, "HTTP_PROXY": proxy,
-				"no_proxy": "operator.example," + loopback + ",192.168.1.10",
-				"NO_PROXY": "operator.example," + loopback + ",192.168.1.10",
-			},
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			clearProxyEnv(t)
-			for name, value := range tc.runner {
-				t.Setenv(name, value)
-			}
-			assert.Equal(t, tc.want, JobProxyEnv(tc.envs, tc.cacheURL, tc.services))
-		})
-	}
-}
-
-// docker-in-docker over tcp: the docker client would otherwise send API calls to a proxy
-// that cannot route to the daemon.
-func TestBypassProxyForDockerHost(t *testing.T) {
-	for _, tc := range []struct {
-		name       string
-		httpProxy  string
-		dockerHost string
-		want       string
-	}{
-		{
-			name:       "tcp daemon is added",
-			httpProxy:  "http://proxy:3128",
-			dockerHost: "tcp://docker:2375",
-			want:       "internal.example,docker",
-		},
-		{
-			name:       "unix socket is left alone",
-			httpProxy:  "http://proxy:3128",
-			dockerHost: "unix:///var/run/docker.sock",
-			want:       "internal.example",
-		},
-		{
-			name:       "nothing happens without a proxy",
-			dockerHost: "tcp://docker:2375",
-			want:       "internal.example",
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			clearProxyEnv(t)
-			t.Setenv("no_proxy", "internal.example")
-			if tc.httpProxy != "" {
-				t.Setenv("http_proxy", tc.httpProxy)
-			}
-
-			BypassProxyForDockerHost(tc.dockerHost)
-
-			assert.Equal(t, tc.want, os.Getenv("no_proxy"))
-		})
-	}
-}
-
-func TestProxyPasswords(t *testing.T) {
-	clearProxyEnv(t)
-	t.Setenv("http_proxy", "http://user:hunter2@proxy:3128")
-	t.Setenv("https_proxy", "http://user:s3cret@proxy:3128")
-	assert.Equal(t, []string{"hunter2", "s3cret"}, proxyPasswords())
-
-	t.Setenv("https_proxy", "http://proxy:3128")
-	assert.Equal(t, []string{"hunter2"}, proxyPasswords())
-}
-
-func TestAppendNoProxy(t *testing.T) {
-	assert.Equal(t, "a.example,b.example", appendNoProxy(" a.example , b.example "))
-	// a host already listed is not repeated
-	assert.Equal(t, "cache.local", appendNoProxy("cache.local", "cache.local"))
-	assert.Empty(t, appendNoProxy("", "", ""))
-}
-
-func TestHostOf(t *testing.T) {
-	assert.Equal(t, "cache.local", hostOf("http://cache.local:8088/"))
-	assert.Equal(t, "192.168.1.10", hostOf("http://192.168.1.10:34567"))
-	// nothing to bypass for a socket path or an unparseable URL
-	assert.Empty(t, hostOf("unix:///var/run/docker.sock"))
-	assert.Empty(t, hostOf("cache.local:8088"))
-	assert.Empty(t, hostOf("://nope"))
-}

internal/app/run/runner.go

@@ -14,7 +14,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"strconv"
 	"strings"
 	"sync"
@@ -67,13 +66,6 @@ type Runner struct {
 	runningCount            atomic.Int64
 	lastIdleCleanupUnixNano atomic.Int64
 	now                     func() time.Time
-	healthCheckLast         time.Time
-	healthCheckReady        bool
-	healthCheckReason       string
-	healthStatusSet         bool
-	healthStatusReady       bool
-	healthStatusReason      string
-	runHealthCheck          func(context.Context, string, time.Duration, map[string]string) error
 }
 
 func NewRunner(cfg *config.Config, reg *config.Registration, cli client.Client) *Runner {
@@ -90,7 +82,6 @@ func NewRunner(cfg *config.Config, reg *config.Registration, cli client.Client)
 		if cfg.Cache.ExternalServer != "" {
 			envs["ACTIONS_CACHE_URL"] = cfg.Cache.ExternalServer
 		} else {
-			warnIgnoredCacheSecret(cfg)
 			handler, err := artifactcache.StartHandler(
 				cfg.Cache.Dir,
 				cfg.Cache.Host,
@@ -118,14 +109,13 @@ func NewRunner(cfg *config.Config, reg *config.Registration, cli client.Client)
 	envs["GITEA_ACTIONS_RUNNER_VERSION"] = ver.Version()
 
 	runner := &Runner{
-		name:           reg.Name,
+		name:         reg.Name,
-		cfg:            cfg,
+		cfg:          cfg,
-		client:         cli,
+		client:       cli,
-		labels:         ls,
+		labels:       ls,
-		envs:           envs,
+		envs:         envs,
-		cacheHandler:   cacheHandler,
+		cacheHandler: cacheHandler,
-		now:            time.Now,
+		now:          time.Now,
-		runHealthCheck: executeHealthCheck,
 	}
 	return runner
 }
@@ -269,8 +259,7 @@ func (r *Runner) Run(ctx context.Context, task *runnerv1.Task) error {
 
 	ctx, cancel := context.WithTimeout(ctx, r.cfg.Runner.Timeout)
 	defer cancel()
-	// A proxy URL may carry credentials, and every job is given it; keep them out of the log.
+	reporter := report.NewReporter(ctx, cancel, r.client, task, r.cfg)
-	reporter := report.NewReporter(ctx, cancel, r.client, task, r.cfg, proxyPasswords()...)
 	var runErr error
 	defer func() {
 		r.runningCount.Add(-1)
@@ -326,7 +315,7 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 		}
 	}()
 
-	r.reportSetup(reporter, task)
+	reporter.Logf("%s(version:%s) received task %v of job %v, be triggered by event: %s", r.name, ver.Version(), task.Id, task.Context.Fields["job"].GetStringValue(), task.Context.Fields["event_name"].GetStringValue())
 
 	workflow, jobID, err := generateWorkflow(task)
 	if err != nil {
@@ -343,11 +332,6 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 	taskContext := task.Context.Fields
 	envs := r.cloneEnvs()
 
-	// Added per task because this job's service containers must be reached directly, and
-	// act reaches them by their workflow key.
-	proxyEnv := JobProxyEnv(envs, envs["ACTIONS_CACHE_URL"], slices.Sorted(maps.Keys(job.Services)))
-	maps.Copy(envs, proxyEnv)
-
 	if r.capabilities != "" {
 		envs["GITEA_ACTIONS_CAPABILITIES"] = r.capabilities
 	}
@@ -457,12 +441,10 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 		LogOutput:            true,
 		JSONLogger:           false,
 		Env:                  envs,
-		ProxyEnv:             proxyEnv,
 		Secrets:              task.Secrets,
 		GitHubInstance:       strings.TrimSuffix(r.client.Address(), "/"),
 		AutoRemove:           true,
 		NoSkipCheckout:       true,
-		DisableActEnv:        r.cfg.Runner.SetActEnv != nil && !*r.cfg.Runner.SetActEnv,
 		PresetGitHubContext:  preset,
 		EventJSON:            string(eventJSON),
 		ContainerNamePrefix:  fmt.Sprintf("GITEA-ACTIONS-TASK-%d", task.Id),
@@ -479,12 +461,9 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 		DefaultActionInstance:             r.getDefaultActionsURL(task),
 		DefaultActionInstanceIsSelfHosted: r.isSelfHostedActionsURL(task),
 		PlatformPicker:                    r.labels.PickPlatform,
-		JobStartedHook:                    r.cfg.Runner.Hooks.JobStarted,
-		JobCompletedHook:                  r.cfg.Runner.Hooks.JobCompleted,
 		Vars:                              task.Vars,
 		ValidVolumes:                      r.cfg.Container.ValidVolumes,
 		InsecureSkipTLS:                   r.cfg.Runner.Insecure,
-		RunnerName:                        r.name,
 	}
 
 	rr, err := runner.New(runnerConfig)
@@ -524,11 +503,14 @@ func (r *Runner) run(ctx context.Context, task *runnerv1.Task, reporter *report.
 // function the caller must invoke (typically via defer) to revoke the
 // credential when the task finishes.
 //
-// Two modes:
+// Three modes:
 //   - Embedded handler: register in-process via RegisterJob.
-//   - external_server: POST to the remote server's /_internal/register, defer a
+//   - external_server + external_secret: POST to the remote server's
-//     POST to /_internal/revoke. This is what enables full per-job auth and
+//     /_internal/register, defer a POST to /_internal/revoke. This is what
-//     repo scoping over the network.
+//     enables full per-job auth and repo scoping over the network.
+//   - external_server alone (no secret): no-op revoker. The remote server is
+//     in legacy openMode and ignores the runtime token; trust is at the
+//     network layer.
 //
 // Safe with an empty token (older Gitea did not issue one).
 func (r *Runner) registerCacheForTask(token, repo string, reporter *report.Reporter) func() {
@@ -541,7 +523,6 @@ func (r *Runner) registerCacheForTask(token, repo string, reporter *report.Repor
 	if r.cfg.Cache.ExternalServer != "" && r.cfg.Cache.ExternalSecret != "" {
 		return r.registerExternalCacheJob(token, repo, reporter)
 	}
-	// No cache server to register against: caching is disabled, or the built-in server failed to start.
 	return func() {}
 }
 
@@ -597,67 +578,6 @@ func (r *Runner) RunningCount() int64 {
 	return r.runningCount.Load()
 }
 
-// CanAcceptTask checks local admission conditions without consuming a task. It is
-// called only from the poll loop, so the cached health fields need no lock.
-func (r *Runner) CanAcceptTask(ctx context.Context) (bool, string) {
-	if !r.cfg.HealthCheck.Enabled {
-		return true, "ok"
-	}
-
-	if r.RunningCount() > 0 {
-		if !r.healthStatusSet {
-			return true, "health checks deferred while jobs are running"
-		}
-		return r.healthStatusReady, r.healthStatusReason
-	}
-
-	if ready, reason := checkFreeDisk(r.cfg); !ready {
-		r.setHealthStatus(ready, reason)
-		return false, reason
-	}
-	ready, reason := r.checkConfiguredHealth(ctx)
-	r.setHealthStatus(ready, reason)
-	return ready, reason
-}
-
-func (r *Runner) setHealthStatus(ready bool, reason string) {
-	r.healthStatusSet = true
-	r.healthStatusReady = ready
-	r.healthStatusReason = reason
-}
-
-// checkFreeDisk evaluates the configured task-admission disk threshold.
-func checkFreeDisk(cfg *config.Config) (bool, string) {
-	root := cfg.Host.WorkdirParent
-	if cfg.Container.BindWorkdir {
-		root = filepath.FromSlash("/" + strings.TrimLeft(cfg.Container.WorkdirParent, "/"))
-	}
-	root = nearestExistingPath(root)
-	available, err := freeDiskBytes(root)
-	if err != nil {
-		return false, fmt.Sprintf("cannot determine free disk space for %s: %v", root, err)
-	}
-	availableMB := available / (1024 * 1024)
-	if availableMB < uint64(cfg.HealthCheck.MinFreeDiskSpaceMB) {
-		return false, fmt.Sprintf("low disk space on %s: %d MiB available, %d MiB required", root, availableMB, cfg.HealthCheck.MinFreeDiskSpaceMB)
-	}
-	return true, "ok"
-}
-
-func nearestExistingPath(path string) string {
-	for path != "" {
-		if _, err := os.Stat(path); err == nil {
-			return path
-		}
-		parent := filepath.Dir(path)
-		if parent == path {
-			return parent
-		}
-		path = parent
-	}
-	return "."
-}
-
 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(),
@@ -665,20 +585,3 @@ func (r *Runner) Declare(ctx context.Context, labels []string) (*connect.Respons
 		Capabilities: RunnerCapabilities(),
 	}))
 }
-
-// warnIgnoredCacheSecret flags an external cache server secret configured on a runner that uses the built-in cache server.
-func warnIgnoredCacheSecret(cfg *config.Config) {
-	if cfg.Cache.ExternalServer != "" {
-		return
-	}
-	// Not using an external cache server, so any configured secret is ignored.
-	if cfg.Cache.ExternalSecret == "" {
-		return
-	}
-	// LoadDefault resolves external_secret_file into ExternalSecret, so report whichever key the operator actually wrote.
-	key := "cache.external_secret"
-	if cfg.Cache.ExternalSecretFile != "" {
-		key = "cache.external_secret_file"
-	}
-	log.Warnf("%s is set but cache.external_server is not; the built-in cache server does not use a shared secret, so the value is ignored", key)
-}

internal/app/run/runner_test.go

@@ -75,7 +75,7 @@ func TestNewRunnerInitializesLabelsAndEnvironment(t *testing.T) {
 	cfg.Runner.Envs = map[string]string{"EXISTING": "value"}
 	reg := &config.Registration{
 		Name:   "runner",
-		Labels: []string{"ubuntu:host", "", "pool:e57e18d4"},
+		Labels: []string{"ubuntu:host", "bad:vm:label"},
 	}
 	cli := clientmocks.NewClient(t)
 	cli.On("Address").Return("https://gitea.example/").Maybe()
@@ -83,8 +83,7 @@ func TestNewRunnerInitializesLabelsAndEnvironment(t *testing.T) {
 	r := NewRunner(cfg, reg, cli)
 
 	require.Equal(t, "runner", r.name)
-	require.Len(t, r.labels, 2)
+	require.Len(t, r.labels, 1)
-	require.Equal(t, []string{"ubuntu", "pool:e57e18d4"}, r.labels.Names())
 	require.Equal(t, "value", r.envs["EXISTING"])
 	require.Equal(t, "https://gitea.example/api/actions_pipeline/", r.envs["ACTIONS_RUNTIME_URL"])
 	require.Equal(t, "https://gitea.example", r.envs["ACTIONS_RESULTS_URL"])
@@ -93,24 +92,6 @@ func TestNewRunnerInitializesLabelsAndEnvironment(t *testing.T) {
 	require.Nil(t, r.cacheHandler)
 }
 
-// Proxy variables are assembled per task, because a job's service containers have to be
-// reached directly and they are only known once the workflow is parsed.
-func TestNewRunnerLeavesProxyToTheTask(t *testing.T) {
-	clearProxyEnv(t)
-	t.Setenv("http_proxy", "http://proxy:3128")
-
-	cfg := &config.Config{}
-	cfg.Cache.ExternalServer = "http://cache.local:8088/"
-	reg := &config.Registration{Name: "runner"}
-	cli := clientmocks.NewClient(t)
-	cli.On("Address").Return("https://gitea.example/").Maybe()
-
-	r := NewRunner(cfg, reg, cli)
-
-	require.NotContains(t, r.envs, "http_proxy")
-	require.NotContains(t, r.envs, "no_proxy")
-}
-
 func taskWithDefaultActionsURL(url string) *runnerv1.Task {
 	return &runnerv1.Task{
 		Context: &structpb.Struct{

internal/app/run/setup.go

@@ -1,83 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"strconv"
-	"strings"
-
-	"gitea.com/gitea/runner/internal/pkg/report"
-	"gitea.com/gitea/runner/internal/pkg/ver"
-
-	runnerv1 "gitea.dev/actions-proto-go/runner/v1"
-)
-
-// osReleasePath describes the host distribution on Linux; absent elsewhere, where the platform
-// falls back to the Go runtime alone. A var so tests can point it at a fixture.
-var osReleasePath = "/etc/os-release"
-
-// reportSetup opens the job log the way actions/runner opens its "Set up job" step. The action
-// downloads and the closing job name are written later, as the job starts.
-func (r *Runner) reportSetup(reporter *report.Reporter, task *runnerv1.Task) {
-	for _, line := range r.setupLines(task) {
-		reporter.Logf("%s", line)
-	}
-}
-
-// setupLines names the runner, then reports what it was asked to run and the host it runs on, each
-// in its own group.
-func (r *Runner) setupLines(task *runnerv1.Task) []string {
-	fields := task.Context.Fields
-	lines := []string{
-		fmt.Sprintf("%s(version:%s)", r.name, ver.Version()),
-		"::group::Runner Information",
-	}
-	if names := r.labels.Names(); len(names) > 0 {
-		lines = append(lines, "Runner labels: "+strings.Join(names, ", "))
-	}
-	lines = append(lines,
-		// The task id correlates the job log with the runner's log and the server's task list.
-		fmt.Sprintf("Task: %d", task.Id),
-		"Job: "+fields["job"].GetStringValue(),
-		"Repository: "+fields["repository"].GetStringValue(),
-		"Triggered by event: "+fields["event_name"].GetStringValue(),
-		"::endgroup::",
-		"::group::Operating System",
-	)
-	lines = append(lines, osInfo()...)
-	return append(lines, "::endgroup::")
-}
-
-// osInfo describes the host the runner executes on.
-func osInfo() []string {
-	lines := make([]string, 0, 2)
-	if name := prettyOSName(); name != "" {
-		lines = append(lines, name)
-	}
-	return append(lines, fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH))
-}
-
-// prettyOSName reads PRETTY_NAME (e.g. "Ubuntu 24.04.4 LTS") from os-release, or "" when absent.
-func prettyOSName() string {
-	data, err := os.ReadFile(osReleasePath)
-	if err != nil {
-		return ""
-	}
-
-	for line := range strings.SplitSeq(string(data), "\n") {
-		key, value, ok := strings.Cut(strings.TrimSpace(line), "=")
-		if !ok || key != "PRETTY_NAME" {
-			continue
-		}
-		// Values are shell-quoted, but the quotes are optional.
-		if unquoted, err := strconv.Unquote(value); err == nil {
-			return unquoted
-		}
-		return value
-	}
-	return ""
-}

internal/app/run/setup_test.go

@@ -1,103 +0,0 @@
-// Copyright 2026 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package run
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"gitea.com/gitea/runner/internal/pkg/labels"
-	"gitea.com/gitea/runner/internal/pkg/ver"
-
-	runnerv1 "gitea.dev/actions-proto-go/runner/v1"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/types/known/structpb"
-)
-
-func TestSetupLines(t *testing.T) {
-	original := osReleasePath
-	path := filepath.Join(t.TempDir(), "os-release")
-	require.NoError(t, os.WriteFile(path, []byte("PRETTY_NAME=\"Ubuntu 24.04.4 LTS\"\n"), 0o600))
-	osReleasePath = path
-	defer func() { osReleasePath = original }()
-
-	r := &Runner{
-		name: "gitea-com-gitea-0003",
-		labels: labels.Labels{
-			{Name: "ubuntu-latest", Schema: labels.SchemeDocker, Arg: "//node:20"},
-			{Name: "ubuntu-22.04", Schema: labels.SchemeDocker, Arg: "//node:20"},
-		},
-	}
-	taskCtx, err := structpb.NewStruct(map[string]any{
-		"job":        "lint",
-		"repository": "gitea/runner",
-		"event_name": "pull_request",
-	})
-	require.NoError(t, err)
-
-	assert.Equal(t, []string{
-		"gitea-com-gitea-0003(version:" + ver.Version() + ")",
-		"::group::Runner Information",
-		"Runner labels: ubuntu-latest, ubuntu-22.04",
-		"Task: 268506",
-		"Job: lint",
-		"Repository: gitea/runner",
-		"Triggered by event: pull_request",
-		"::endgroup::",
-		"::group::Operating System",
-		"Ubuntu 24.04.4 LTS",
-		fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH),
-		"::endgroup::",
-	}, r.setupLines(&runnerv1.Task{Id: 268506, Context: taskCtx}))
-}
-
-func TestPrettyOSName(t *testing.T) {
-	tests := map[string]struct {
-		osRelease string
-		want      string
-	}{
-		"quoted value": {
-			osRelease: "NAME=\"Ubuntu\"\nVERSION_ID=\"24.04\"\nPRETTY_NAME=\"Ubuntu 24.04.4 LTS\"\n",
-			want:      "Ubuntu 24.04.4 LTS",
-		},
-		"unquoted value": {
-			osRelease: "PRETTY_NAME=Alpine Linux v3.21\n",
-			want:      "Alpine Linux v3.21",
-		},
-		"no pretty name": {
-			osRelease: "NAME=\"Ubuntu\"\nVERSION_ID=\"24.04\"\n",
-			want:      "",
-		},
-		// A key that merely ends in PRETTY_NAME must not be mistaken for it.
-		"similar key": {
-			osRelease: "IMAGE_PRETTY_NAME=\"Ubuntu Core 24\"\n",
-			want:      "",
-		},
-	}
-
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			path := filepath.Join(t.TempDir(), "os-release")
-			require.NoError(t, os.WriteFile(path, []byte(tt.osRelease), 0o600))
-
-			original := osReleasePath
-			osReleasePath = path
-			defer func() { osReleasePath = original }()
-
-			assert.Equal(t, tt.want, prettyOSName())
-		})
-	}
-
-	t.Run("missing file", func(t *testing.T) {
-		original := osReleasePath
-		osReleasePath = filepath.Join(t.TempDir(), "absent")
-		defer func() { osReleasePath = original }()
-
-		assert.Empty(t, prettyOSName())
-	})
-}

internal/pkg/client/http.go

@@ -10,8 +10,6 @@ import (
 	"strings"
 	"time"
 
-	"gitea.com/gitea/runner/internal/pkg/ver"
-
 	"connectrpc.com/connect"
 	"gitea.dev/actions-proto-go/ping/v1/pingv1connect"
 	"gitea.dev/actions-proto-go/runner/v1/runnerv1connect"
@@ -38,7 +36,6 @@ func New(endpoint string, insecure bool, uuid, token string, opts ...connect.Cli
 
 	opts = append(opts, connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
 		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
-			req.Header().Set("User-Agent", "gitea-runner/"+ver.Version())
 			if uuid != "" {
 				req.Header().Set(UUIDHeader, uuid)
 			}

internal/pkg/config/config.example.yaml

@@ -39,7 +39,7 @@ runner:
   # 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: 5s
+  fetch_interval_max: 1m
   # While idle, remove stale bind-workdir task directories and orphaned host-mode
   # scratch directories (left behind when a host cleanup delete stalls) older than
   # this duration. Setting either workdir_cleanup_age or idle_cleanup_interval to 0
@@ -72,9 +72,6 @@ runner:
   # When true (the default), fetch only the requested ref of an action repository (e.g. actions/checkout@v4) at depth 1 instead of cloning every branch's full history. 
   # Set to false to clone the full history.
   action_shallow_clone: true
-  # When true (the default), inject the ACT=true environment variable into jobs.
-  # Set to false so workflows gated on `if: ${{ !env.ACT }}` behave like they do on GitHub.
-  set_act_env: true
   # The labels of a runner are used to determine which jobs the runner can run, and how to run them.
   # Like: "macos-arm64:host" or "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
   # Find more images provided by Gitea at https://gitea.com/gitea/runner-images .
@@ -104,14 +101,6 @@ runner:
   post_task_script: ''
   # Hard limit on post_task_script runtime. Default if omitted: 5m.
   post_task_script_timeout: 5m
-  # Scripts run inside the job environment before the job's first step and after its last
-  # one, the equivalent of GitHub's ACTIONS_RUNNER_HOOK_JOB_STARTED and
-  # ACTIONS_RUNNER_HOOK_JOB_COMPLETED, which are read when these are unset. The paths are
-  # resolved inside the job environment. Either one failing fails the job.
-  # Full guide: docs/job-hooks.md
-  hooks:
-    job_started: ''
-    job_completed: ''
 
 cache:
   # Enable the built-in cache server (used by actions/cache and similar actions).
@@ -121,11 +110,6 @@ cache:
   dir: ""
   # Outbound IP or hostname that job containers use to reach this runner's cache server.
   # Leave empty to detect automatically. 0.0.0.0 is not valid here.
-  # If the runner itself runs in Docker, automatic detection can choose an
-  # address on the runner container's network that job containers cannot reach
-  # when the runner creates a separate per-job network. In that case, set this
-  # to a hostname/IP reachable from job containers, and set port to a fixed
-  # published port or put the job containers on a shared Docker network.
   # Ignored when external_server is set.
   host: ""
   # Port for the built-in cache server. 0 picks a random free port.
@@ -140,11 +124,6 @@ cache:
   # Required when external_server is set. Must be identical on every runner and the cache-server.
   # Generate with: openssl rand -hex 32
   external_secret: ""
-  # Path to a file containing the shared secret, as an alternative to external_secret.
-  # Use this to keep the secret out of this file.
-  # Surrounding whitespace is trimmed, so a trailing newline in the file is fine.
-  # Setting both external_secret and external_secret_file is an error.
-  external_secret_file: ""
   # When true, reuse a cached action instead of fetching from the remote on every job.
   # A moved tag (e.g. a re-tagged "v6") or an updated branch stays at the cached commit
   # until its cache entry expires or is manually removed.
@@ -154,8 +133,6 @@ container:
   # Specifies the network to which the container will connect.
   # Could be host, bridge or the name of a custom network.
   # If it's empty, runner will create a network automatically.
-  # For dockerized runners using the built-in cache server, a custom shared
-  # network can be required so job containers can reach cache.host/cache.port.
   # Deprecated: `network_mode` is still accepted for old configs; use `network` instead.
   network: ""
   # network_create_options only apply when `network` is left empty and the runner
@@ -167,11 +144,7 @@ container:
     enable_ipv6: false # Omit to use Docker's default (IPv6 disabled). Enabling it requires dockerd started with --ipv6.
   # Whether to use privileged mode or not when launching task containers (privileged mode is required for Docker-in-Docker).
   privileged: false
-  # Any other options to be used when the container is started, for example:
+  # Any other options to be used when the container is started (e.g., --add-host=my.gitea.url:host-gateway).
-  #   options: --add-host=my.gitea.url:host-gateway
-  # A volume declared here replaces the one the runner mounts on the same container path, so the
-  # tool cache can be kept on the host. Its source must also be allowed by valid_volumes below:
-  #   options: --volume /host/toolcache:/opt/hostedtoolcache
   options:
   # The parent directory of a job's working directory.
   # NOTE: There is no need to add the first '/' of the path as runner will add it automatically.
@@ -195,9 +168,8 @@ container:
   # If it's "-", runner will find an available docker host automatically, but the docker host won't be mounted to the job containers and service containers.
   # If it's not empty or "-", the specified docker host will be used. An error will be returned if it doesn't work.
   docker_host: ""
-  # Pull docker image(s) even if already present.
+  # Pull docker image(s) even if already present
-  # Defaults to false when the key is omitted.
+  force_pull: true
-  force_pull: false
   # Rebuild docker image(s) even if already present
   force_rebuild: false
   # Always require a reachable docker daemon, even if not required by runner
@@ -216,29 +188,11 @@ host:
   # If it's empty, $HOME/.cache/act/ will be used.
   workdir_parent:
 
-# Optional local task-admission checks. Disabled by default. When enabled, low
-# disk space or a failing script pauses new task fetching; existing jobs continue.
-# No health checks run while any job is active; the last result is reused until idle.
-health_check:
-  enabled: false
-  # Minimum free space required on the filesystem holding runner workspaces.
-  # Defaults to 1024 MiB when omitted or set to zero.
-  min_free_disk_space_mb: 1024
-  # Optional additional executable. A non-zero exit, timeout, or startup failure
-  # marks the runner unavailable.
-  script: ''
-  # How long a script result is cached and its maximum execution time.
-  interval: 30s
-  timeout: 10s
-
 metrics:
   # Enable the Prometheus metrics endpoint.
-  # When enabled, metrics are served at /metrics, liveness at /healthz, and
+  # When enabled, metrics are served at http://<addr>/metrics and a liveness check at /healthz.
-  # task-admission readiness at /readyz.
   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"
-  # Consecutive polling failures may last this long before /readyz returns 503.
-  readiness_grace: 30s

internal/pkg/config/config.go

@@ -4,13 +4,11 @@
 package config
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"maps"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/joho/godotenv"
@@ -51,29 +49,20 @@ type Runner struct {
 	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
 	ActionShallowClone    *bool             `yaml:"action_shallow_clone"`     // ActionShallowClone fetches only the requested ref of an action repository at depth 1 instead of cloning every branch's full history. It is a pointer to distinguish between false and not set; if not set, it defaults to true.
-	SetActEnv             *bool             `yaml:"set_act_env"`              // SetActEnv controls whether the ACT=true environment variable is injected into jobs. It is a pointer to distinguish between false and not set; if not set, it defaults to true. Set it to false so workflows gated on `if: ${{ !env.ACT }}` behave like on GitHub.
 	AllocatePTY           bool              `yaml:"allocate_pty"`             // AllocatePTY allocates a pseudo-TTY for each step's process. Default is false, matching GitHub's actions/runner. Enable only for jobs that need an interactive terminal; tools like docker build emit redrawing progress frames into the captured log when a TTY is present. Applies to both host and docker backends.
 	PostTaskScript        string            `yaml:"post_task_script"`         // PostTaskScript is the path to an executable script run on the host after each task's cleanup completes. Empty disables the hook. On Windows use .exe/.bat/.cmd; PowerShell (.ps1) is not supported yet as the configured path.
 	PostTaskScriptTimeout time.Duration     `yaml:"post_task_script_timeout"` // PostTaskScriptTimeout caps how long the post-task script may run. Default is 5m when post_task_script is set.
-	Hooks                 RunnerHooks       `yaml:"hooks"`                    // Hooks are scripts run inside the job environment around the job's steps.
-}
-
-// RunnerHooks represents the scripts run inside the job environment around the job's steps.
-type RunnerHooks struct {
-	JobStarted   string `yaml:"job_started"`   // JobStarted is the path of a script run before the job's first step. Falls back to ACTIONS_RUNNER_HOOK_JOB_STARTED; a failure fails the job.
-	JobCompleted string `yaml:"job_completed"` // JobCompleted is the path of a script run after the job's last step, while the job environment is still up. Falls back to ACTIONS_RUNNER_HOOK_JOB_COMPLETED; a failure fails the job.
 }
 
 // Cache represents the configuration for caching.
 type Cache struct {
-	Enabled            *bool  `yaml:"enabled"`              // Enabled indicates whether caching is enabled. It is a pointer to distinguish between false and not set. If not set, it will be true.
+	Enabled        *bool  `yaml:"enabled"`         // Enabled indicates whether caching is enabled. It is a pointer to distinguish between false and not set. If not set, it will be true.
-	Dir                string `yaml:"dir"`                  // Dir specifies the directory path for caching.
+	Dir            string `yaml:"dir"`             // Dir specifies the directory path for caching.
-	Host               string `yaml:"host"`                 // Host specifies the caching host.
+	Host           string `yaml:"host"`            // Host specifies the caching host.
-	Port               uint16 `yaml:"port"`                 // Port specifies the caching port.
+	Port           uint16 `yaml:"port"`            // Port specifies the caching port.
-	ExternalServer     string `yaml:"external_server"`      // ExternalServer specifies the URL of external cache server
+	ExternalServer string `yaml:"external_server"` // ExternalServer specifies the URL of external cache server
-	ExternalSecret     string `yaml:"external_secret"`      // ExternalSecret is a shared secret between this runner and an external gitea-runner cache-server, enabling per-job ACTIONS_RUNTIME_TOKEN authentication and repo scoping over the network. Required whenever ExternalServer is set; ExternalSecretFile is the alternative way to provide it.
+	ExternalSecret string `yaml:"external_secret"` // ExternalSecret is a shared secret between this runner and an external gitea-runner cache-server, enabling per-job ACTIONS_RUNTIME_TOKEN authentication and repo scoping over the network. Leave empty to keep the legacy unauthenticated behavior.
-	ExternalSecretFile string `yaml:"external_secret_file"` // ExternalSecretFile is the path to a file holding the ExternalSecret value, so the secret can be mounted instead of stored in the config file. LoadDefault reads it into ExternalSecret; setting both is an error.
+	OfflineMode    bool   `yaml:"offline_mode"`    // OfflineMode reuses a cached action without fetching from the remote; a moved tag or branch stays at the cached commit until the cache entry is removed.
-	OfflineMode        bool   `yaml:"offline_mode"`         // OfflineMode reuses a cached action without fetching from the remote; a moved tag or branch stays at the cached commit until the cache entry is removed.
 }
 
 // Container represents the configuration for the container.
@@ -105,30 +94,18 @@ type Host struct {
 
 // Metrics represents the configuration for the Prometheus metrics endpoint.
 type Metrics struct {
-	Enabled        bool          `yaml:"enabled"`         // Enabled indicates whether the metrics endpoint is exposed.
+	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").
+	Addr    string `yaml:"addr"`    // Addr specifies the listen address for the metrics HTTP server (e.g., ":9101").
-	ReadinessGrace time.Duration `yaml:"readiness_grace"` // ReadinessGrace permits transient polling errors before /readyz becomes unhealthy.
-}
-
-// HealthCheck represents local checks that control whether the runner accepts
-// new tasks. The entire feature is opt-in through Enabled.
-type HealthCheck struct {
-	Enabled            bool          `yaml:"enabled"`                // Enabled activates local task-admission health checks.
-	MinFreeDiskSpaceMB int64         `yaml:"min_free_disk_space_mb"` // MinFreeDiskSpaceMB is the minimum free space required on the work volume.
-	Script             string        `yaml:"script"`                 // Script is an optional executable used as an additional health check.
-	Interval           time.Duration `yaml:"interval"`               // Interval controls how long a script result is cached.
-	Timeout            time.Duration `yaml:"timeout"`                // Timeout caps one health-check script invocation.
 }
 
 // Config represents the overall configuration.
 type Config struct {
-	Log         Log         `yaml:"log"`          // Log represents the configuration for logging.
+	Log       Log       `yaml:"log"`       // Log represents the configuration for logging.
-	Runner      Runner      `yaml:"runner"`       // Runner represents the configuration for the runner.
+	Runner    Runner    `yaml:"runner"`    // Runner represents the configuration for the runner.
-	Cache       Cache       `yaml:"cache"`        // Cache represents the configuration for caching.
+	Cache     Cache     `yaml:"cache"`     // Cache represents the configuration for caching.
-	Container   Container   `yaml:"container"`    // Container represents the configuration for the container.
+	Container Container `yaml:"container"` // Container represents the configuration for the container.
-	Host        Host        `yaml:"host"`         // Host represents the configuration for the host.
+	Host      Host      `yaml:"host"`      // Host represents the configuration for the host.
-	Metrics     Metrics     `yaml:"metrics"`      // Metrics represents the configuration for the Prometheus metrics endpoint.
+	Metrics   Metrics   `yaml:"metrics"`   // Metrics represents the configuration for the Prometheus metrics endpoint.
-	HealthCheck HealthCheck `yaml:"health_check"` // HealthCheck controls opt-in local task-admission checks.
 }
 
 // LoadDefault returns the default configuration.
@@ -144,7 +121,6 @@ func LoadDefault(file string) (*Config, error) {
 		if err := yaml.Unmarshal(content, cfg); err != nil {
 			return nil, fmt.Errorf("parse config file %q: %w", file, err)
 		}
-		warnUnknownKeys(file, content)
 		definedRunnerKeys, err = definedRunnerConfigKeys(content)
 		if err != nil {
 			return nil, fmt.Errorf("parse config file %q for defaults metadata: %w", file, err)
@@ -180,38 +156,24 @@ func LoadDefault(file string) (*Config, error) {
 		b := true
 		cfg.Runner.ActionShallowClone = &b
 	}
-	if cfg.Runner.SetActEnv == nil {
-		b := true
-		cfg.Runner.SetActEnv = &b
-	}
 	if cfg.Cache.Enabled == nil {
 		b := true
 		cfg.Cache.Enabled = &b
 	}
-	// Resolved regardless of cache.enabled, because the `cache-server` command reads the secret from the same key without checking cache.enabled.
-	if err := resolveCacheExternalSecret(cfg); err != nil {
-		return nil, err
-	}
 	if *cfg.Cache.Enabled {
 		if cfg.Cache.Dir == "" {
-			home, err := os.UserHomeDir()
+			home, _ := os.UserHomeDir()
-			if err != nil {
-				return nil, fmt.Errorf("cache.dir is unset and the user home directory could not be determined: %w", err)
-			}
 			cfg.Cache.Dir = filepath.Join(home, ".cache", "actcache")
 		}
 		if cfg.Cache.ExternalServer != "" && cfg.Cache.ExternalSecret == "" {
-			return nil, errors.New("cache.external_server is set but no shared secret is configured; set cache.external_secret (or cache.external_secret_file) to the same value used by the gitea-runner cache-server")
+			return nil, errors.New("cache.external_server is set but cache.external_secret is empty; configure the same external_secret on this runner and the gitea-runner cache-server")
 		}
 	}
 	if cfg.Container.WorkdirParent == "" {
 		cfg.Container.WorkdirParent = "workspace"
 	}
 	if cfg.Host.WorkdirParent == "" {
-		home, err := os.UserHomeDir()
+		home, _ := os.UserHomeDir()
-		if err != nil {
-			return nil, fmt.Errorf("host.workdir_parent is unset and the user home directory could not be determined: %w", err)
-		}
 		cfg.Host.WorkdirParent = filepath.Join(home, ".cache", "act")
 	}
 	if cfg.Runner.FetchTimeout <= 0 {
@@ -221,7 +183,7 @@ func LoadDefault(file string) (*Config, error) {
 		cfg.Runner.FetchInterval = 2 * time.Second
 	}
 	if cfg.Runner.FetchIntervalMax <= 0 {
-		cfg.Runner.FetchIntervalMax = 5 * time.Second
+		cfg.Runner.FetchIntervalMax = time.Minute
 	}
 	if cfg.Runner.WorkdirCleanupAge == 0 && !definedRunnerKeys["workdir_cleanup_age"] {
 		cfg.Runner.WorkdirCleanupAge = 24 * time.Hour
@@ -247,21 +209,9 @@ func LoadDefault(file string) (*Config, error) {
 	if cfg.Runner.PostTaskScript != "" && cfg.Runner.PostTaskScriptTimeout <= 0 {
 		cfg.Runner.PostTaskScriptTimeout = DefaultPostTaskScriptTimeout
 	}
-	if cfg.HealthCheck.MinFreeDiskSpaceMB <= 0 {
-		cfg.HealthCheck.MinFreeDiskSpaceMB = 1024
-	}
-	if cfg.HealthCheck.Interval <= 0 {
-		cfg.HealthCheck.Interval = 30 * time.Second
-	}
-	if cfg.HealthCheck.Timeout <= 0 {
-		cfg.HealthCheck.Timeout = 10 * time.Second
-	}
 	if cfg.Metrics.Addr == "" {
 		cfg.Metrics.Addr = "127.0.0.1:9101"
 	}
-	if cfg.Metrics.ReadinessGrace <= 0 {
-		cfg.Metrics.ReadinessGrace = 30 * time.Second
-	}
 
 	// Validate and fix invalid config combinations to prevent confusing behavior.
 	if cfg.Runner.FetchIntervalMax < cfg.Runner.FetchInterval {
@@ -290,21 +240,6 @@ func LoadDefault(file string) (*Config, error) {
 	return cfg, nil
 }
 
-// warnUnknownKeys reports keys the config does not define, which are otherwise ignored
-// without a trace. It only warns, so a config carrying keys from another runner version
-// still loads.
-func warnUnknownKeys(file string, content []byte) {
-	decoder := yaml.NewDecoder(bytes.NewReader(content))
-	decoder.KnownFields(true)
-
-	var typeErr *yaml.TypeError
-	if err := decoder.Decode(&Config{}); errors.As(err, &typeErr) {
-		for _, message := range typeErr.Errors {
-			log.Warnf("config file %q: %s, it will be ignored", file, message)
-		}
-	}
-}
-
 func definedRunnerConfigKeys(content []byte) (map[string]bool, error) {
 	var root yaml.Node
 	if err := yaml.Unmarshal(content, &root); err != nil {
@@ -331,24 +266,3 @@ func definedRunnerConfigKeys(content []byte) (map[string]bool, error) {
 
 	return defined, nil
 }
-
-// resolveCacheExternalSecret loads cache.external_secret from the file named by cache.external_secret_file,
-// so deployments can mount the secret instead of committing it to the config file.
-func resolveCacheExternalSecret(cfg *Config) error {
-	if cfg.Cache.ExternalSecretFile == "" {
-		return nil
-	}
-	if cfg.Cache.ExternalSecret != "" {
-		return errors.New("cache.external_secret and cache.external_secret_file are both set; configure only one of them")
-	}
-	content, err := os.ReadFile(cfg.Cache.ExternalSecretFile)
-	if err != nil {
-		return fmt.Errorf("read cache.external_secret_file %q: %w", cfg.Cache.ExternalSecretFile, err)
-	}
-	secret := strings.TrimSpace(string(content))
-	if secret == "" {
-		return fmt.Errorf("cache.external_secret_file %q contains no secret", cfg.Cache.ExternalSecretFile)
-	}
-	cfg.Cache.ExternalSecret = secret
-	return nil
-}

internal/pkg/config/config_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -49,39 +48,10 @@ func TestLoadDefault_DefaultsWorkdirCleanupAge(t *testing.T) {
 	assert.Equal(t, 10*time.Minute, cfg.Runner.IdleCleanupInterval)
 }
 
-func TestLoadDefault_HealthChecksAreOptIn(t *testing.T) {
+func TestLoadDefault_DefaultsIdleFetchBackoffMax(t *testing.T) {
 	cfg, err := LoadDefault("")
 	require.NoError(t, err)
-	assert.False(t, cfg.HealthCheck.Enabled)
+	assert.Equal(t, time.Minute, cfg.Runner.FetchIntervalMax)
-	assert.Equal(t, int64(1024), cfg.HealthCheck.MinFreeDiskSpaceMB)
-	assert.Empty(t, cfg.HealthCheck.Script)
-	assert.Equal(t, 30*time.Second, cfg.HealthCheck.Interval)
-	assert.Equal(t, 10*time.Second, cfg.HealthCheck.Timeout)
-	assert.False(t, cfg.Metrics.Enabled)
-}
-
-func TestLoadDefault_DiskAndReadinessSettings(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-health_check:
-  enabled: true
-  min_free_disk_space_mb: 4096
-  script: /usr/local/bin/runner-health
-  interval: 15s
-  timeout: 3s
-metrics:
-  readiness_grace: 45s
-`), 0o600))
-
-	cfg, err := LoadDefault(path)
-	require.NoError(t, err)
-	assert.True(t, cfg.HealthCheck.Enabled)
-	assert.Equal(t, int64(4096), cfg.HealthCheck.MinFreeDiskSpaceMB)
-	assert.Equal(t, "/usr/local/bin/runner-health", cfg.HealthCheck.Script)
-	assert.Equal(t, 15*time.Second, cfg.HealthCheck.Interval)
-	assert.Equal(t, 3*time.Second, cfg.HealthCheck.Timeout)
-	assert.Equal(t, 45*time.Second, cfg.Metrics.ReadinessGrace)
 }
 
 func TestLoadDefault_UsesConfiguredWorkdirCleanupAge(t *testing.T) {
@@ -140,6 +110,9 @@ runner:
 	assert.Equal(t, -1*time.Second, cfg.Runner.IdleCleanupInterval)
 }
 
+// TestLoadDefault_MalformedYAMLReturnsParseError pins the error surfaced for
+// invalid YAML to the canonical "parse config file" message rather than the
+// "for defaults metadata" variant — i.e. the main yaml.Unmarshal runs first.
 func TestLoadDefault_LoadsPostTaskScript(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "config.yaml")
@@ -168,25 +141,6 @@ runner:
 	assert.Equal(t, 5*time.Minute, cfg.Runner.PostTaskScriptTimeout)
 }
 
-func TestLoadDefault_LoadsJobHooks(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-runner:
-  hooks:
-    job_started: /hooks/started.sh
-    job_completed: /hooks/completed.sh
-`), 0o600))
-
-	cfg, err := LoadDefault(path)
-	require.NoError(t, err)
-	assert.Equal(t, "/hooks/started.sh", cfg.Runner.Hooks.JobStarted)
-	assert.Equal(t, "/hooks/completed.sh", cfg.Runner.Hooks.JobCompleted)
-}
-
-// TestLoadDefault_MalformedYAMLReturnsParseError pins the error surfaced for
-// invalid YAML to the canonical "parse config file" message rather than the
-// "for defaults metadata" variant — i.e. the main yaml.Unmarshal runs first.
 func TestLoadDefault_MalformedYAMLReturnsParseError(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "config.yaml")
@@ -198,21 +152,6 @@ func TestLoadDefault_MalformedYAMLReturnsParseError(t *testing.T) {
 	assert.NotContains(t, err.Error(), "defaults metadata")
 }
 
-func TestLoadDefault_WarnsOnUnknownKeysButStillLoads(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte("container:\n  volumes:\n    - /host:/ctr\n  privileged: true\n"), 0o600))
-
-	hook := test.NewGlobal()
-	defer hook.Reset()
-
-	cfg, err := LoadDefault(path)
-	require.NoError(t, err)
-	assert.True(t, cfg.Container.Privileged)
-	require.Len(t, hook.Entries, 1)
-	assert.Contains(t, hook.LastEntry().Message, "field volumes not found")
-}
-
 func TestContainerNetworkCreateOptions(t *testing.T) {
 	// Verify that the enable_ipv4/enable_ipv6 YAML keys unmarshal into the *bool fields,
 	// distinguishing an explicit true/false from an omitted key (nil). A nil here is
@@ -259,91 +198,3 @@ func TestContainerNetworkCreateOptions(t *testing.T) {
 		assert.Nil(t, opts.EnableIPv6)
 	})
 }
-
-func TestLoadDefault_ReadsExternalSecretFromFile(t *testing.T) {
-	dir := t.TempDir()
-	secretPath := filepath.Join(dir, "cache.secret")
-	require.NoError(t, os.WriteFile(secretPath, []byte("  s3cr3t\n"), 0o600))
-
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-cache:
-  enabled: true
-  external_server: "http://cache.invalid/"
-  external_secret_file: "`+secretPath+`"
-`), 0o600))
-
-	cfg, err := LoadDefault(path)
-	require.NoError(t, err)
-	assert.Equal(t, "s3cr3t", cfg.Cache.ExternalSecret)
-}
-
-func TestLoadDefault_ReadsExternalSecretFromFileWhenCacheDisabled(t *testing.T) {
-	dir := t.TempDir()
-	secretPath := filepath.Join(dir, "cache.secret")
-	require.NoError(t, os.WriteFile(secretPath, []byte("s3cr3t"), 0o600))
-
-	// the file has to be resolved even when cache is disabled
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-cache:
-  enabled: false
-  external_secret_file: "`+secretPath+`"
-`), 0o600))
-
-	cfg, err := LoadDefault(path)
-	require.NoError(t, err)
-	assert.Equal(t, "s3cr3t", cfg.Cache.ExternalSecret)
-}
-
-func TestLoadDefault_RejectsBothExternalSecretAndFile(t *testing.T) {
-	dir := t.TempDir()
-	secretPath := filepath.Join(dir, "cache.secret")
-	require.NoError(t, os.WriteFile(secretPath, []byte("s3cr3t"), 0o600))
-
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-cache:
-  enabled: true
-  external_server: "http://cache.invalid/"
-  external_secret: "inline"
-  external_secret_file: "`+secretPath+`"
-`), 0o600))
-
-	_, err := LoadDefault(path)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "both set")
-}
-
-func TestLoadDefault_RejectsMissingExternalSecretFile(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-cache:
-  enabled: true
-  external_server: "http://cache.invalid/"
-  external_secret_file: "`+filepath.Join(dir, "absent.secret")+`"
-`), 0o600))
-
-	_, err := LoadDefault(path)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "read cache.external_secret_file")
-}
-
-func TestLoadDefault_RejectsEmptyExternalSecretFile(t *testing.T) {
-	dir := t.TempDir()
-	secretPath := filepath.Join(dir, "cache.secret")
-	require.NoError(t, os.WriteFile(secretPath, []byte("\n  \n"), 0o600))
-
-	path := filepath.Join(dir, "config.yaml")
-	require.NoError(t, os.WriteFile(path, []byte(`
-cache:
-  enabled: true
-  external_server: "http://cache.invalid/"
-  external_secret_file: "`+secretPath+`"
-`), 0o600))
-
-	_, err := LoadDefault(path)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "contains no secret")
-}