lar-06 reproduction

Public source retained with the related article. Generated results, dependency directories, runtime storage, secrets, and oversized binary artifacts are intentionally excluded.

README

# LAR-06 cache freshness fixture

This fixture treats SQLite as the authoritative catalogue source and Redis as
a derived cache and shared lock store. It pins Laravel 13.20.0, PHP 8.4.12,
Predis 3.2.0, Redis 8.2.3, and every container image.

The first checkpoint proves that the Laravel application can preserve an
inspectable cache envelope and enforce lock ownership through the shared Redis
store:

```sh
./run.sh
```

The smoke result is retained in `results/smoke.json`. The same runner retains
seven source-revision and invalidation cases in `results/profile.json`: a
no-cache control, TTL-only staleness, after-commit invalidation, early
invalidation followed by rollback, lost invalidation, versioned-key selection,
and a reordered old event which cannot replace a newer pointer. The verifier checks
the exact cache and source revisions instead of a hit-ratio or timing score.

The evidence gate also fetches and hashes thirteen primary sources, retains an
eighteen-row score-free decision record, rejects twenty isolated semantic
mutations, audits the locked Composer dependencies, and records a source
manifest. Drafting remains closed until this complete runner also passes from
a clean committed-tree export.

`results/concurrency.json` retains five real-process cases. Twelve unlocked
readers expose duplicated origin work; the correctly sized shared lock
coalesces it; a short lease exposes overlapping owners; a designated owner
keeps eleven immediate waiters from entering; and a crashed owner recovers only
after its lease expires. Timing is descriptive. The verifier uses exact origin
counts, lock outcomes, response hashes, and recovery state.

`results/flexible.json` exercises Laravel 13.20's actual `flexible` method with
a controlled Carbon clock. It retains cold, fresh, stale, refreshed, expired,
and failed-refresh branches. A twelve-process stale case records every revision
1 response before releasing deferred callbacks; Laravel's internal refresh
lock and creation check allow one revision 2 rebuild.

`results/failures.json` and `results/cache-unavailable.json` keep cache
absence, cache unavailability, write refusal, corrupt envelopes, response hash
mismatch, source
unavailability, lock timeout, and deferred refresh failure distinct. A Redis
ACL user supplies a real read-success/write-refusal control. Reader-specific
policies decide whether current source, verified stale data, or failure is the
honest outcome.

The configured Redis server has persistence disabled because it is a disposable
local evidence dependency, not a model of production durability or topology.

After committing the fixture, reproduce it without untracked workspace input:

```sh
./bin/run-clean-export.sh <commit>
```

Retained files