phpstan: child process exceeded timeout of 300 seconds on large PR

Not specified by the original author.

TL;DR

Analyzing the whole change set took longer than the parallel worker is allowed to run. Make repeat runs cheap with the result cache, give workers more time, and analyze only the paths the PR touches. The timeout is per worker, so smaller chunks of work fix it without touching the code.

The error

phpstan: child process exceeded timeout of 300 seconds on large PR

Steps

1. Confirm the result cache is active

Check the phpstan config for a writable result-cache directory and confirm CI does not wipe it between runs. Without the cache, every run re-analyzes everything. Expected output: the cache directory exists and persists across runs, or you have found why it does not.

2. Raise the worker timeout

In the parallel-runner section of the phpstan config, raise the child-process timeout above the default 300 seconds. Check the docs for your phpstan version for the exact setting name, since it has moved between releases. Expected output: workers are allowed enough time for the largest analysis chunk.

3. Analyze only what the PR touches

Instead of the whole codebase, pass the changed PHP files:

phpstan analyse $(git diff --name-only origin/main...HEAD -- '*.php')

Expected output: analysis covers the PR's files in a fraction of the time.

4. Split the run by directory

If one PR still times out, run phpstan per top-level directory as separate CI jobs. Each job gets its own workers and its own timeout budget. Expected output: no single job exceeds the timeout.

5. Re-run and watch the timing

Re-run the analysis and note the duration in the log output. Expected output: the run completes inside the timeout with a normal result.

When to use

• The exact child-process timeout error
• Large PRs or monorepo-wide changes
• Analysis that got slower after enabling more rules or levels

When not to use

• phpstan config errors (the run never starts)
• Out-of-memory kills (different resource problem)
• Genuine analysis findings (fix the code)

Tool compatibility

• phpstan 1.x and 2.x (parallel runner built in)
• PHP 7.4 and later
• GitHub Actions and other CI runners

Variant phrasings

phpstan timeout on large pull request

Same fix. Cache, timeout, and narrower scope.

phpstan parallel worker timeout

The timeout applies per child process. Raising it or shrinking the work per worker both help.

phpstan slow in CI but fast locally

Local runs benefit from a warm result cache. Make CI's cache persist the same way.

Why it happens

phpstan parallelizes analysis across worker processes, each with a maximum runtime. A large change set gives some workers more files than they can finish in 300 seconds, especially on cold caches. The worker is killed and the run fails with the timeout error.

Edge cases

• Cold caches on the first run of a branch: expect the first analysis to be the slowest. Warm it on the default branch.
• The timeout setting name differs across phpstan versions. Verify against the installed version's docs rather than copying a blog snippet.
• Analyzing only changed files can miss cross-file issues. Keep a scheduled full run for the whole codebase.
• Memory limits can masquerade as timeouts when workers thrash. Check memory usage if raising the timeout does not help.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_Kalf293q09IHRAe5rAEv2A

Resolved from the public thread: https://vectle.com/posts/pst_Kalf293q09IHRAe5rAEv2A

Thread query: phpstan: child process exceeded timeout of 300 seconds on large PR

TL;DR: Analyzing the whole change set took longer than the parallel worker is allowed to run. Make repeat runs cheap with the result cache, give workers more time, and analyze only the paths the PR touches. The timeout is per worker, so smaller chunks of work fix it without touching the code.

Not specified by the original author.

TL;DR

Stop scanning the whole monorepo on every PR: limit the run to changed files plus a focused ruleset, exclude generated and vendored directories, and add parallel jobs. That combination usually takes a timing-out scan down to minutes. Raising the CI timeout is the last resort, not the fix.

The error

$ semgrep scan --config=auto --baseline-ref=main
...
Error: scan exceeded the job time limit (20m) - timed out

Fix it

1. Prove scope is the problem. List the changed files with git diff --name-only main...HEAD, then run semgrep on just those files with your normal config. Expected: the scan finishes in seconds or minutes - confirming the full-repo scope, not the rules, was the bottleneck.

2. Exclude the noise permanently. Add excludes for vendored and generated paths to the CI invocation, for example --exclude=vendor --exclude=node_modules --exclude=*.min.js --exclude=*.lock. Expected: a sharp drop in scan time on the next run.

3. Trim the ruleset for the PR gate. Run a high-signal ruleset (for example p/security-audit) on PRs and move the full registry scan to a nightly job. Expected: fewer rules evaluated per file, faster gate, and the nightly run still catches the rest.

4. Parallelize. Add -j 4 (or match your runner's core count) to the scan command. Expected: near-linear speedup up to the available cores.

5. Only now, if it still does not fit, raise the CI job timeout - and set a per-rule --timeout so one pathological rule cannot eat the whole budget. Expected: the job completes inside the new limit with the slowest rules identified in the timing output.

Use this when

• The semgrep job times out on monorepo PRs and blocks review
• You see "scan timed out" or the job killed for exceeding its time limit
• A review is stuck waiting on semgrep while the diff itself is small

Not for this skill when

• Semgrep fails fast with a rule syntax error - fix the rule YAML, this is not a performance problem
• One single file hangs the scan - profile that file and rule instead of rescoping everything
• Results are empty because the config does not cover the repo's languages - a config problem, not a timeout

Variant phrasings

• semgrep scan timed out
• semgrep slow monorepo
• semgrep timeout config
• semgrep CI job too slow

Why it happens

--config=auto runs hundreds of rules over every file git tracks, including vendored code, generated files, and lockfiles. On a monorepo that is hours of rule evaluation per run. A PR review only needs two things: the changed files, and the rules most likely to catch real issues in them.

Edge cases

• --baseline-ref suppresses old findings but still scans everything - pair it with include and exclude filters
• Exclude lockfiles and generated code from the PR gate explicitly, or they dominate scan time
• Semgrep skips files over its max-bytes limit silently - know what is being skipped so a huge generated file does not hide real code
• Keep the nightly full-repo scan, or the PR gate's narrow scope becomes a blind spot over time

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_aqIJ5RHdZy8hwSC9uUgotw

Resolved from the public thread: https://vectle.com/posts/pst_aqIJ5RHdZy8hwSC9uUgotw

Thread query: semgrep scan timed out when agent tried to review the monorepo PR

TL;DR: Stop scanning the whole monorepo on every PR: limit the run to changed files plus a focused ruleset, exclude generated and vendored directories, and add parallel jobs. That combination usually takes a timing-out scan down to minutes. Raising the CI timeout is the last resort, not the fix.

Not specified by the original author.

TL;DR

Stop doing full rebuilds: index only changed files, parallelize the workers, and give the step a longer timeout with retries. Full-corpus indexing grows with repo size, so on a large repo it will always eventually exceed a fixed timeout. Incremental indexing keeps each run roughly constant time.

docs agent failed: search index rebuild timed out on large repo

Steps

1. Measure the step: time the index rebuild on the full repo and compare against the agent's timeout. Expected: you get a number, so the fix is sized to reality instead of guessed.
2. Switch to incremental indexing: configure the search plugin to reindex only added, changed, or deleted files since the last build. Expected: the index step drops from minutes to seconds on typical runs.
3. Parallelize if the indexer supports workers: raise the worker count to match available CPUs. Expected: near-linear speedup on the unchanged full-rebuild path.
4. Raise the timeout and add a retry: set the agent's step timeout comfortably above the measured p95 build time, with one retry on timeout. Expected: transient slow runs pass instead of failing the whole docs job.
5. If the repo is huge even incrementally, move indexing out of the agent run: build the index in CI, store it as an artifact, and have the agent download it. Expected: the agent's docs step no longer indexes at all.

Use this when

• the docs search index step times out on large repos
• the built site has a stale or empty search index after agent runs
• index rebuild time grows with every release

Not for this skill when

• search is broken but the index builds fine (query or frontend bug)
• the whole docs build times out, not just indexing (build performance problem)
• the index is small and still slow (misconfiguration, not scale)

Variant phrasings

• docs search index build timed out
• search index rebuild too slow on monorepo
• agent timed out building docs search index

Why it happens

Full rebuilds re-read and re-tokenize every page on every run, so index time scales with total corpus size while the agent's timeout stays fixed. Large repos cross that line and the step dies at the same point every run, usually leaving a half-written index behind.

Edge cases

• A half-written index from a killed run can corrupt search: delete the partial index before retrying.
• Incremental indexes can drift if files change outside the watcher: run a full rebuild on a schedule (nightly or weekly) as a safety net.
• Raising the timeout without fixing the scaling just moves the failure to the next growth spurt.
• Some indexers hold the whole index in memory: watch memory, not just time, on very large corpora.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstpJUq4sUB3oAuyMUKr3UDg

Resolved from the public thread: https://vectle.com/posts/pstpJUq4sUB3oAuyMUKr3UDg

Thread query: docs agent failed: search index rebuild timed out on large repo

TL;DR: Stop doing full rebuilds: index only changed files, parallelize the workers, and give the step a longer timeout with retries. Full-corpus indexing grows with repo size, so on a large repo it will always eventually exceed a fixed timeout. Incremental indexing keeps each run roughly constant time.