> ## Content Index
> Fetch the complete content index at: https://debugly.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# GitHub pull_request_target Blocked? Check Policy Before the Runner
- URL: https://debugly.dev/github-pull-request-target-blocked-policy-runner/
- Published: 2026-11-03T03:54:07.000Z
- Updated: 2026-11-03T03:54:07.000Z
- Description: GitHub's December 2 default policy and November brownouts can fail a run before jobs execute. Separate event-policy blocks from checkout and runner failures.
- Author: Rohit Bhadani
- Tags: Security, GitHub Actions, CI/CD

**Editorial disclosure:** This is an AI-prepared, documentation-based explainer, not a personally reproduced incident. The audit command below is illustrative and has not been executed against a production repository. See the [editorial policy](https://debugly.dev/editorial-policy/).

A pull request arrives. GitHub shows a failed workflow. You open it expecting a broken test, but there is no test output to inspect.

Before changing the runner image or retrying the job, establish whether the job was allowed to start. A workflow rejected at the event-policy boundary needs a different fix from a process that exited on a runner.

That distinction matters for GitHub's next `pull_request_target` rollout. Its [November 2 announcement](https://github.blog/changelog/2026-11-02-pull%5Frequest%5Ftarget-blocked-by-default-december-2/?ref=debugly.dev) moves permanent default enforcement to **December 2, 2026**. This article describes the announced schedule as of November 3; it is not a report of enforcement already happening everywhere.

## The dates to put beside the failure

GitHub lists two temporary enforcement windows: **November 9 and November 16, 16:00–18:00 UTC**. During these brownouts, attempts blocked by the default rule will produce failed runs with an error annotation, without executing the workflow. Outside the windows, the default returns to evaluation until permanent enforcement.

The announcement covers public repositories on GitHub Free, Team and Enterprise Cloud. Private and internal repositories, and GitHub Enterprise Server, are outside this change's stated scope. An applicable explicit event policy also matters: the default is not a reason to ignore policies your organization already configured.

## The trigger changes which code gets trusted

`pull_request_target` is useful precisely because it runs with the base repository's trusted context. GitHub's [security guide](https://docs.github.com/en/actions/reference/security/securely-using-pull%5Frequest%5Ftarget?ref=debugly.dev) explains that the default workflow and checkout come from the base repository's default branch. That makes authenticated triage possible without automatically executing a contributor's proposed code.

The boundary breaks when a privileged workflow fetches the fork's head and then builds or tests it. The checkout is only the first link. The build command, dependency installation or project script is where untrusted content becomes running code with that job's authority.

Changing only the event name can also produce a quieter mistake: a job may stay green while testing the base branch instead of the proposed change. A successful run is not evidence that the intended revision was tested. Record the event, workflow revision and checked-out revision separately.

For ordinary fork CI that does not require privileged context, assess `pull_request`. For metadata work that genuinely requires `pull_request_target`, keep contributor-controlled code out of execution. Those are different jobs, even when they concern the same pull request.

## Diagnose the first boundary that failed

| Evidence                                             | What to inspect next                                 |
| ---------------------------------------------------- | ---------------------------------------------------- |
| Policy annotation; no job steps executed             | Event policy, repository scope and rollout window    |
| Checkout step started and rejected the requested ref | Checkout inputs and its fork-code protections        |
| Build or test process actually started               | Its logs, environment and tested revision            |
| Green result, but no evidence of the PR revision     | Which branch was checked out and what the job tested |

This is a diagnostic order, not a promise that every missing job is this rollout. A conditional expression, approval requirement or another policy can prevent work too. Keep the actual annotation with the event name and timestamp; do not infer the cause from a red badge alone.

Three checks are easy to confuse: permission to start a workflow, permission to fetch a revision, and permission to execute what was fetched. Passing one does not establish the others. That is why loosening a token permission is a poor first response to a run rejected before its jobs exist.

## Audit before granting an exception

Start with a read-only inventory. This illustrative command finds obvious trigger and checkout references; it is not a complete security audit and has not been run on your repository:

```
rg -n 'pull_request_target|workflow_run|head\.sha|head\.repo|refs/pull' .github/workflows
```

For each hit, write down what the job needs to do, which revision it consumes, whether it executes contributor-controlled content, and which credentials it receives. Review reusable workflows and scripts reached from it as well. Searching the YAML is the index into that review, not its conclusion.

GitHub's [workflow execution controls](https://docs.github.com/en/actions/how-tos/administer/control-workflow-execution?ref=debugly.dev) live under Settings → Actions → Policies at repository or organization level. Policies can target particular workflow paths and layer across account levels. Review policy insights while evaluation is available, then decide whether the affected workflow needs the privileged event at all. Where an exception is justified, scope it to the reviewed workflow instead of treating every workflow as equivalent.

A policy exception answers whether a workflow may run. It does not establish that the workflow is safe. Separately, the require-lockfile protection concerns action dependencies; adopting a lockfile is not a substitute for reviewing which pull-request content a privileged job executes.

## Do not move the same trust mistake downstream

Splitting CI and authenticated reporting can reduce what the untrusted stage receives. It can also preserve the vulnerability if the trusted stage downloads an artifact and executes it. GitHub Security Lab's [pwn-request analysis](https://securitylab.github.com/resources/github-actions-preventing-pwn-requests/?ref=debugly.dev) makes this boundary explicit: artifacts originating from a pull request remain untrusted input.

A coverage number treated as data and a downloaded binary treated as a command are not equivalent. Review parsing, identifiers and subsequent shell use as part of that handoff. “Another workflow produced it” is provenance, not permission to execute it.

Debugly's [npm trusted-publishing investigation](https://debugly.dev/npm-trusted-publishing-hijack/) covers a related identity boundary. Here the immediate question is earlier: which event was allowed to start privileged work, and which code did that work consume?

Before the first brownout, pick one workflow you expect to remain functional. Record its policy decision, intended revision, credential boundary and expected output. After the change, verify those four facts again. A pipeline is not healthy merely because the badge turned green; it needs to run the right code with the right authority.