Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI

[alexeygrigorev]

Grooming decision

Filed as a new issue rather than a #179 amendment. The introducing change is the owner's direct-to-main d8d5f27 ("Refresh homepage copy", 2026-08-18), which postdates #179's contract work — 8424b2c (2026-08-17) had already moved the then-current subtitle through the smoke pin and warned about exactly this miss class. #179 also remains held open by an unrelated [human] item (member-story placeholder copy) that this fix cannot discharge, and the durable guard below is new scope. This fix discharges the deploy side of #179's deploy/smoke.py acceptance criterion; #179's acceptance verifies it there.

Problem

The deploy job of run 32226341286 (main CI on b487b1f, the #196 merge push) failed at "Promote or roll back one atomic web-and-worker release" with release failed safely: home page lacks expected content: Free, project-based courses where you learn to build and build to learn. Every other job was green (playwright, django, quality, container, ci-gate, auto-capture-prior, publish) — only the deploy contract failed.

Root cause (verified): deploy/smoke.py run_http_smoke expects three home strings; the first two are current, but the third (line 192) still pins the pre-refresh subtitle. d8d5f27 changed templates/core/home.html's hero-lede to Free, hands-on courses in data and AI, with a clear path, practical work, and a community to help you get unstuck. and updated core/tests/test_homepage.py, but missed the smoke pin — the second instance of the miss class 8424b2c's message warns about. The Django suite cannot catch this class: core/tests/test_deployment_release.py (~line 2686) feeds run_http_smoke synthetic response bodies, so template↔contract drift is invisible until a live deploy.

The failure predates #196 (d8d5f27 is an ancestor of #196's frozen base 397bcd7; #196 changed one spec file only) — the push merely exposed it. This blocks the green push run #193's landing criteria expect.

Grep-verified: the only live pins of the old subtitle are deploy/smoke.py:192 and core/tests/test_deployment_release.py:2690 (other hits are a stale snapshot under .claude/worktrees/, out of scope). HOME_IDENTITY_MARKER (deploy/smoke.py:30) and the title pin are already the refreshed copy.

Scope

• Update the third expected home string in deploy/smoke.py run_http_smoke to the current hero-lede rendered by templates/core/home.html (exact sentence or opening words is engineering's call; the guard below keeps whichever form in lockstep with the template).
• Update the synthetic passing-home body in core/tests/test_deployment_release.py (~line 2690) to serve the new subtitle, so the happy path exercises the new pin, and re-pin that file's sha256 in _docs/compatibility/development-terminology-allowlist.json (the 8424b2c precedent).
• Add the durable guard: a focused Django test that imports the home-page content strings run_http_smoke pins — title, HOME_IDENTITY_MARKER, and the subtitle — from deploy.smoke (single source of truth; extract a module-level tuple if that keeps it honest) and asserts each appears in the Django-rendered / response, and that the adopted course-discovery lede (Learn data skills. For free. Together.) stays absent from it. Template↔contract drift then fails Django CI instead of the deploy job. test_deployment_release.py already imports deploy.smoke, so importability in the Django suite is proven.

Non-goals

• No template or copy change: d8d5f27's copy is the intended content; the contract follows the template, not the reverse.
• No change to the rest of the release contract (health, version footer, canonical, /unified/, /courses checks) or to the synthetic-body testing approach beyond the string update.
• No Playwright changes (playwright was green on b487b1f).
• No reopening of Rebuild the public homepage on the design 5a mockup #179's design work or its member-stories human item.

Acceptance criteria

• run_http_smoke's home content pins (title, HOME_IDENTITY_MARKER, subtitle) all match the current rendered homepage; the old subtitle pin is gone from deploy/smoke.py.
• The synthetic passing-home body in core/tests/test_deployment_release.py contains the new subtitle; the file's terminology-allowlist sha256 is re-pinned and make terminology-check is green.
• The new Django guard test sources the pinned strings from deploy.smoke (not re-typed literals), asserts each appears in the rendered / response and the course-discovery lede stays absent, and passes at head.
• Focused Django tests, make test-ci, lint, format-check, and typecheck green; verification plan per _docs/ci/change-selective-ci.md with all component dispositions recorded.
• Screenshots: not_applicable — no product-page render change (the template is untouched), per _docs/PROCESS.md.

Landing expectation: on-call observes the next main push promote successfully through the deploy job; that green run is also what #193's landing criteria await.

Dependencies: none. Unblocks #193's landing (green push run); discharges the deploy side of #179's smoke criterion.

Normative references: _docs/PROCESS.md (red pipeline attribution), _docs/ci/change-selective-ci.md, _docs/specs/02-url-link-seo-compatibility.md (home canonical/title contract).

[alexeygrigorev]

Software Engineer Report

Worktree: .tmp/website-198-engineer (branch issue-198-smoke-subtitle-repin, frozen uncommitted; no push, no commit)
Base = Head: b487b1fc44372d83f35a2edd09457e6535ad189a (= current main; plan is worktree-inclusive: 3 modified + 1 added file)
Graph digest: 4127118b4467a75b40b8dbadc4050b5b2dc3762b292aca93cd9309a4593bca19 (policy v4) · Plan digest: 32e799b3cfbd46699377c5acf5a8e6bc5179366762bdef432c0d53a04049baee
Profile: full (reason test_infrastructure; risk flags deployment_runtime, shared_runtime, test_infrastructure; direct nodes shared.core, surface.deploy, surface.documentation; no unknown paths)
Render decision: impact false → Screenshots: not_applicable (template untouched; per issue and _docs/PROCESS.md)

Changed files

File	Rationale
deploy/smoke.py	Extracted the three home pins into module-level HOME_CONTENT_PINS (title, HOME_IDENTITY_MARKER, refreshed hero lede, byte-exact from templates/core/home.html:646); run_http_smoke now iterates the tuple. The stale pre-refresh subtitle pin is gone. Behavior of every other check is unchanged.
core/tests/test_deployment_release.py	Passing-home synthetic body now serves the new subtitle; the negative "home identity" case became "home subtitle": title + marker + version + static present, stale subtitle served, so it fails exactly at the new third pin (home page lacks expected content: Free, hands-on courses…).
core/tests/test_home_release_contract.py (new)	Durable guard: imports HOME_CONTENT_PINS/HOME_IDENTITY_MARKER from deploy.smoke (no re-typed literals) and asserts each pin appears in the rendered / response, plus the adopted course-discovery lede (Learn data skills. For free. Together.) stays absent. Template↔contract drift now fails Django CI.
_docs/compatibility/development-terminology-allowlist.json	Re-pinned core/tests/test_deployment_release.py sha256 → e6a812581c33798318683a95bf56e52e9a1b728c5c2de214d472e21b5bda7451 (the 8424b2c maneuver; sandbox-term count verified unchanged at 7, so expected_count stays 7).

No model changes → no migrations. No template/copy changes (per non-goals).

Gate verdicts (exact commands and counts)

• make terminology-check — green ("Development terminology inventory is classified.")
• make lint — green ("All checks passed!")
• make format-check — green ("559 files already formatted")
• make typecheck — green ("Success: no issues found in 417 source files")
• Focused: DJANGO_SETTINGS_MODULE=website.settings.test uv run --frozen python manage.py test --noinput core.tests.test_home_release_contract core.tests.test_deployment_release.RemoteSmokeSafetyTests — Ran 4 tests, OK
• Full module: … manage.py test --noinput core.tests.test_deployment_release core.tests.test_home_release_contract — Ran 59 tests, OK
• Full suite: make test — attempt 1 aborted in the parallel runner on test_support.tests.test_migrations (TransactionManagementError, known parallel flake class); solo re-run … manage.py test --noinput test_support.tests.test_migrations — Ran 9 tests, OK; attempt 2 — Ran 2255 tests, OK (skipped=9) incl. the compatibility stage
• make verification-plan — produced .tmp/verification/verification-plan.json (digest above)
• make test-ci (via runner evidence_validation) — green, 531

Four-bucket report (from verification-run, attempt 2)

• rerun (green): selector, evidence_validation (531), quality (531), content_invariants
• rerun (executed, environment-failed — see blocker): django (exit 2, OperationalError('database or disk is full') mid-suite), playwright (exit 2, terminated after a reproducible teardown wedge), container (no envelope, OSError: [Errno 28] No space left on device)
• reused: none (fresh run; no prior envelope matches this plan)
• not_applicable: compatibility (outside computed impact), screenshots (render impact false)
• No final aggregate report file was produced (verification-report-check not reached). No component is silently skipped; the three environment-failed components must be re-run before tester handoff can be considered complete.

Artifacts: .tmp/verification/verification-plan.json, .tmp/verification/evidence/*-result.json|-output.log (28 files), logs .tmp/verification-198/ in the worktree.

Blocker: machine root filesystem exhausted (not introduced by #198)

During the run, / (436G) went from ~330MB to 0 bytes free. Effects, all recorded: playwright core wedges at suite teardown (reproduced 2/2 in this worktree at the same point after the final module test_version_footers.py; the unrelated .tmp/website-195-engineer worktree — which does not contain this change — froze identically for 35+ min), the runner's django component aborted with database or disk is full, and the container check hit Errno 28. The same suite completed on this machine at 07:15 today and playwright was green on b487b1f in CI run 32226341286. This change has zero browser surface (no template/static/js/fixture edits; graph render impact false). I cleaned only my own stale run dirs (~150MB); historical worktrees/data are not mine to delete. Re-run when the machine has headroom: make verification-run VERIFY_WORKTREE=issue-198-smoke-subtitle-repin VERIFY_ISSUE=198.

Behavior and limitations

After this fix, run_http_smoke's home pins match the live homepage copy (d8d5f27), so the deploy job should promote; the next homepage copy refresh without a re-pin now fails the focused Django guard instead of a 17-minute deploy. Limitations: verification aggregate incomplete pending the disk-headroom re-run above; the first full-suite parallel flake in test_support.tests.test_migrations is pre-existing and passed solo and on retry.

[alexeygrigorev]

Software Engineer Report

Worktree: .tmp/website-198-engineer (branch issue-198-smoke-subtitle-repin, uncommitted, frozen for tester review). Base = HEAD = b487b1fc44372d83f35a2edd09457e6535ad189a (plan head includes the worktree per --include-worktree).

Changed files

• deploy/smoke.py — the three home content pins now live in a module-level tuple HOME_CONTENT_PINS (document title, HOME_IDENTITY_MARKER, and the refreshed hero lede pinned with the exact template bytes from templates/core/home.html:646); run_http_smoke iterates the tuple. The old subtitle pin is gone; the error text is unchanged.
• core/tests/test_deployment_release.py — the mocked passing-home body now serves the new subtitle, and the negative case ("home subtitle") now serves title + marker + the stale subtitle, so it passes the first two pins and fails exactly the new third pin (home page lacks expected content).
• core/tests/test_home_release_contract.py (new) — the durable guard: imports HOME_CONTENT_PINS and HOME_IDENTITY_MARKER from deploy.smoke (single source of truth, no re-typed literals), asserts each pin appears in the Django-rendered / response, and asserts the adopted course-discovery lede (Learn data skills. For free. Together.) stays absent. The next homepage copy refresh without a re-pin now fails Django CI here instead of surfacing as a failed 17-minute deploy job.
• _docs/compatibility/development-terminology-allowlist.json — sha256 for core/tests/test_deployment_release.py re-pinned to e6a812581c33798318683a95bf56e52e9a1b728c5c2de214d472e21b5bda7451 (the 8424b2c maneuver; expected_count stays 7 — the edit adds/removes no former-name occurrences).

Verification plan

make verification-plan → .tmp/verification/verification-plan.json (sha256 32e799b3cfbd46699377c5acf5a8e6bc5179366762bdef432c0d53a04049baee); graph sha256 4127118b4467a75b40b8dbadc4050b5b2dc3762b292aca93cd9309a4593bca19; policy v4; profile full, reason test_infrastructure; risk flags deployment_runtime, shared_runtime, test_infrastructure; direct nodes shared.core, surface.deploy, surface.documentation; no unknown paths; render impact false (no template/static/JS/fixture change).

Four buckets

• rerun (green, envelopes in .tmp/verification/evidence/): selector (exit 0), evidence_validation = make test-ci (531 passed / 0 failed), quality = quality-contract-v1 (531 passed / 0 failed), django = make test (2551 passed / 9 skipped / 0 failed — includes the 2 new guard tests), content_invariants (4 assertions, 1 structured record, exit 0), container (13 assertions, status pass, revision b487b1fc…, artifact container-check.json sha256 8a316c915e06a1a1…; executed via make verification-container after the runner could not reach it — see playwright below).
• rerun (blocked, not validated): playwright (make test-playwright-core). Blocked by pre-existing local-environment defects, proven independent of this diff by A/B against clean base b487b1f:
  1. playwright_tests/test_accessibility.py::test_accessibility_core_smoke[chromium-viewport1-mobile] hangs forever (faulthandler dump shows the main thread inside the Playwright driver event loop with an idle browser — driver-level deadlock; the desktop variant passes in 19s). Reproduced identically at base via git stash A/B (log base-ab-accessibility.log). The same module has the owner's main-checkout run wedged for 12h.
  2. 14 further tests (design-parity / target-spacing class) fail deterministically at head AND at clean base (e.g. test_article_design_parity.py::test_the_article_page_renders_the_design_system_in_both_themes, 3/3 failed in both A/B legs) — local chromium headless_shell-1208 (Playwright 1.58.0) renders geometry differently from CI's browser.
     CI ran playwright green on this exact base (run 32226341286, per this issue's account); my diff has zero browser surface. Logs: .tmp/verification-198/{quiet-core-run,solo-accessibility,base-ab-accessibility,base-ab-failed-tests,faulthandler3}.log in the worktree. Because the runner hangs inside this component, make verification-run cannot emit a final verification-report.json; the six completed components' envelopes are retained above. This local blocker deserves its own issue (testing/infra) and does not gate the CI playwright job.
• reused: none — every executed component is fresh.
• skipped: none. The blocked playwright entry above is the only unexecuted required component and is reported as blocked, not skipped.
• not_applicable: compatibility (plan reason outside_impact_closure); screenshots (plan reason render_inputs_unchanged_without_reusable_visual; also the issue's explicit not_applicable — no product-page render change).

Commands and counts (engineer-side, all uv-backed)

• make terminology-check → green ("Development terminology inventory is classified.")
• make lint → "All checks passed!"; make format-check → "559 files already formatted"; make typecheck → "Success: no issues found in 417 source files"
• DJANGO_SETTINGS_MODULE=website.settings.test … manage.py test core.tests.test_home_release_contract core.tests.test_deployment_release.RemoteSmokeSafetyTests → 4 tests OK; full core.tests.test_deployment_release → 57 OK (combined run: 59 OK)
• make test → 2255 tests, OK (9 skipped). One earlier parallel attempt failed in test_support.tests.test_migrations with TransactionManagementError; that module passes solo (9 OK) and the failure signature matches the machine's root-filesystem exhaustion incident (OSError: [Errno 28], / at 0 bytes) that also wedged two earlier verification attempts — resolved by the coordinator's cleanup (94 stale worktrees removed).

Behavior and limitations

• The deploy contract now expects the rendered homepage copy: run_http_smoke will promote against the refreshed hero lede instead of failing it.
• Drift protection: a future homepage copy change without a pin refresh turns Django CI red (core.tests.test_home_release_contract) rather than failing the deploy job.
• Limitations: local playwright validation blocked as documented; live deploy-side proof lands with on-call on the next main push (this issue's landing expectation); no migration, model, or template changes.

[alexeygrigorev]

Grooming decision on the hang→absent-aggregate observation from this issue's engineering (comment 5341490486): filed as separate issue #199 rather than folding into #195 or #197 — #195 covers counts for components that complete non-successfully inside create_report; this is the runner never reaching report creation (ci/runner.py executes components with no timeout, so the Makefile chain never reaches verification-report-check). #199 adds bounded component execution with terminate-then-kill, a timeout result envelope, and guaranteed aggregate emission with a failure verdict. The underlying local hangs themselves (Playwright driver deadlock in test_accessibility.py, local-versus-CI chromium geometry drift, both A/B-proven at clean base) are environment/test defects outside #199's scope — candidates for their own intake; your base-ab-*.log artifacts are the starting evidence.

[alexeygrigorev]

Correction to my grooming-decision comment above: the two local blockers your report documents (the test_accessibility.py driver deadlock and the 14 design-parity reds) are not intake candidates — they are #193's owned failure classes, reconciled in cdc656a on #193's branch (screenshot-settle lazy-load deadlock and the classes-2-6 reds), with #193's push-run playwright verdict as the acceptance criterion. Do not file a separate issue for them; if either persists locally after #193 lands, the residual gets groomed then with post-#193 evidence. Your base-ab artifacts remain useful exactly as far as they went: proving independence from this diff. The aggregate-report gap those hangs exposed is separately owned by #199.

[alexeygrigorev]

QA Review — PASS

Independent tester verification of the frozen uncommitted diff in .tmp/website-198-engineer (branch issue-198-smoke-subtitle-repin, base = HEAD = b487b1fc44372d83f35a2edd09457e6535ad189a; 3 modified + 1 added file at handoff, unchanged at review).

Method: pristine detached worktree git worktree add --detach .tmp/tester-198-base b487b1f; the tracked diff applied byte-identically (diff of the two git diffs empty) and the new file matches by sha256 (67aa019b26ce305718c2a83bc1a8e26f02c591a4c0c3dd947f172c77ce4ca734). Nothing else is in the diff — verified against the whole worktree status.

Acceptance criteria (all verified independently)

1. Pins match the rendered homepage; old subtitle gone — VERIFIED. All three HOME_CONTENT_PINS entries compared byte-for-byte against templates/core/home.html at base: title DataTalks.Club — free courses for data and AI engineers (exact, em-dash U+2014), HOME_IDENTITY_MARKER (present), hero lede Free, hands-on courses in data and AI, with a clear path, practical work, and a community to help you get unstuck. (byte-exact string equality against the extracted <p class="hero-lede"> text). The stale pin survives nowhere in deploy/; the single remaining occurrence of the old subtitle tree-wide is the intended negative synthetic body (core/tests/test_deployment_release.py:2797).
2. Synthetic body + allowlist re-pin + terminology green — VERIFIED. Computed sha256 of the modified core/tests/test_deployment_release.py = e6a812581c33798318683a95bf56e52e9a1b728c5c2de214d472e21b5bda7451 — exactly the re-pinned value; class/reason/follow_up/expected_count: 7 unchanged. make terminology-check → "Development terminology inventory is classified." (green, my tree).
3. Durable guard — VERIFIED, positive and negative proof:
   • Positive: DJANGO_SETTINGS_MODULE=website.settings.test uv run --frozen python manage.py test --noinput core.tests.test_home_release_contract → 2 tests OK; with RemoteSmokeSafetyTests → 4 OK; full core.tests.test_deployment_release + guard → 59 OK (matches engineer count).
   • Negative (the incident class simulated): changed the live lede mid-string in templates/core/home.html ("a clear path" → "a clear roadmap"), re-ran the guard → FAIL at test_every_home_content_pin_appears_in_the_rendered_home_response with subTest pin='Free, hands-on courses in data and AI, with a clear path, practical work, and a community to help you get unstuck.' — it names the drifted pin. Template reverted; tree re-verified equal to the frozen diff and green again.
   • Sourcing: the guard does from deploy.smoke import HOME_CONTENT_PINS, HOME_IDENTITY_MARKER — no re-typed pin literals (the only literal is the adopted-lede absence assertion, exactly as scoped). The independent HOME_IDENTITY_MARKER assertion also protects against a future tuple edit dropping it.
   • Honest boundary, not a defect: the issue specifies presence assertions, so a purely trailing append to the lede would not trip the guard (the pin would still appear on the page, and run_http_smoke would equally pass). Word-level refreshes — the actual d8d5f27 miss class — are caught, as proven above.
4. Gates green — VERIFIED (my tree, uv/Make):
   • make terminology-check green; make lint "All checks passed!"; make format-check "559 files already formatted"; make typecheck "Success: no issues found in 417 source files" (all identical to the handoff strings).
   • make test (full Django suite, inside my verification run): 2551 passed / 9 skipped / 0 failed — identical to the engineer's django envelope.
   • make test-ci: 531 passed / 0 failed.
   • make verification-plan VERIFY_CONSUMER=tester at base=head b487b1f (worktree-inclusive): graph sha256 4127118b4467a75b40b8dbadc4050b5b2dc3762b292aca93cd9309a4593bca19 — identical to the handoff; render decision identical (impact false, decision sha c018a20d…); profile full, risk flags deployment_runtime, shared_runtime, test_infrastructure, no unknown paths; all nine component dispositions identical (7 rerun; compatibility + screenshots not_applicable). Deep JSON diff of the two plans shows exactly one differing field: created_at. No drift.
5. Screenshots: not_applicable — CORRECT. Render impact false (no template/static/JS/fixture change; changed paths are two test modules, deploy/smoke.py, one allowlist JSON). No product-page render change to capture.

Verification run (my tree, VERIFY_ISSUE=198 explicit)

make verification-run VERIFY_WORKTREE=/home/alexey/git/dtc-website/.tmp/tester-198-base VERIFY_ISSUE=198 VERIFY_CONSUMER=tester — four buckets, tester-final:

• rerun (green): selector (exit 0); evidence_validation = make test-ci (531/0); quality = quality contract (531/0); content_invariants (exit 0, 4 assertions, 1 structured record); django = make test (2551/9/0); container (status pass, 13 assertions, revision b487b1fc…, artifact sha256 8a316c915e06a1a1207c9910088b8f43eb47841f7789d60bce912e9dbe6ff453 — byte-identical to the engineer's artifact).
• rerun (executed; blocked by the documented pre-existing base condition, not by this diff): playwright (make test-playwright-core). My run reproduced the engineer's account exactly: 14 deterministic failures (design-parity / target-spacing class) and then a hard wedge at playwright_tests/test_accessibility.py::test_accessibility_core_smoke[chromium-viewport1-mobile] at 47% — the same terminal line as the engineer's quiet-core-run.log. I confirmed the wedge state directly (0 CPU seconds on both pytest and the Playwright driver across a 30 s window; driver alive) and terminated it (Make error 143). This base condition is proven independent of the diff by the engineer's stash A/B logs (.tmp/verification-198/base-ab-accessibility.log, base-ab-failed-tests.log: the same failures/wedge at clean base b487b1f), which I spot-checked, and independently by the main checkout's own pytest in the same module being wedged 13h42m before my run began. CI ran playwright green on this exact base (run 32226341286). The fix sits unmerged in .tmp/website-193-engineer (open Main Playwright suite is red: design-5a batch landed without a browser verdict #193; now 572d805 "Settle the Playwright suite…", a rebase of the previously cited cdc656a). This diff has zero browser surface. As with the engineer's run, the runner therefore could not emit a final verification-report.json (exit 2 at report-check) — the six completed components' envelopes are retained and validated above; nothing is silently skipped.
• reused: none — every executed component is fresh from my own tree.
• skipped: none.

Envelope/provenance validation

Engineer artifacts re-validated read-only at .tmp/website-198-engineer/.tmp/verification{,-198}/: django envelope ran make test 2026-08-19T09:50:18Z with 2551/9/0 — the newest django evidence is green (the earlier disk-exhausted failures precede it; no older pass accepted after a newer failure); container-check.json sha256 matches the claimed 8a316c91…; plan digest 32e799b3cfbd46699377c5acf5a8e6bc5179366762bdef432c0d53a04049baee is the sha256 of the plan file itself. The handoff's "2255 vs 2551" numbers are the earlier manual make test and the final runner envelope respectively — explained, not drift. My own envelopes live at .tmp/tester-198-base/.tmp/verification/evidence/ (selector, evidence_validation, quality, content_invariants, django, playwright, container *-result|-evidence|-output.log + container-check.json); run log .tmp/tester-198-base/.tmp/verification-198-tester-run.log; plan .tmp/tester-198-base/.tmp/verification/verification-plan.json (sha256 9805c486563d325ba764b05d3e30d3dc49744cd00d17d09d879faeb4057b1a63; differs from the engineer's only by created_at).

Findings

• None against this diff. Scope is exactly the four files; no template/copy change (non-goals respected); no model change → no migrations; no new dependencies; dependency direction sound (test imports deploy.smoke, same precedent as test_deployment_release.py).
• Recorded observations, no action for Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198: (a) the local browser-suite wedge/failures are the documented base condition owned by Main Playwright suite is red: design-5a batch landed without a browser verdict #193 — the unmerged fix there is now 572d805 (rebased from cdc656a); (b) the guard's presence-semantics boundary noted under criterion 3.

Verdict: PASS — return to engineer not required. Landing expectation stands: on-call should observe the deploy job promote on the next main push.

[alexeygrigorev]

Product Acceptance

Verdict: ACCEPT — judged from the perspective the issue names: the next homepage copy refresh must fail Django CI, not a 17-minute deploy.

Independent verification

• Frozen state and digests. Worktree .tmp/website-198-engineer, branch issue-198-smoke-subtitle-repin, base = HEAD = b487b1f, exactly 3 modified + 1 added file. Recomputed: new guard sha256 67aa019b…a734, modified core/tests/test_deployment_release.py sha256 e6a81258…7451 — matching the re-pinned allowlist value (the only line changed there; class/reason/expected_count: 7 untouched). Reviewer-applied diff in a pristine tree matches the frozen diff.
• Diff review. HOME_CONTENT_PINS is a module-level tuple (title with exact em-dash, HOME_IDENTITY_MARKER, refreshed lede) iterated by run_http_smoke with the error text unchanged; the guard imports the pins from deploy.smoke with no re-typed literals (the only literal is the adopted-lede absence assertion, exactly as scoped), and asserts the marker independently of the tuple. The passing-home synthetic body serves the new subtitle; the renamed negative case ("home subtitle") serves title + marker + the stale subtitle so the third pin is proven load-bearing — the old subtitle's single remaining tree occurrence is that intended negative body.
• The perspective test, reproduced myself. In a pristine scratch tree at b487b1f with the frozen diff applied: guard green (2 tests OK). I then replayed the d8d5f27 incident class — reworded the lede in all four template occurrences (three head meta descriptions + the hero paragraph, which is what a real refresh edits together) — and re-ran: FAILED (failures=1) at test_every_home_content_pin_appears_in_the_rendered_home_response, naming the drifted pin verbatim, in 0.15 seconds. The deploy contract's drift window is closed at the Django layer. Tree restored and scratch removed.

The guard's honest boundary — accepted, no follow-up

Presence semantics cannot catch a purely trailing append to the lede. I judge that acceptable for acceptance: it is exactly what this issue specified ("asserts each appears in the rendered response"); in the uncovered case the pinned sentence is still present on the page, so run_http_smoke itself would also pass — the guard and the release contract agree by construction, and there is no state where the guard is green while the deploy would fail on the pins. The real incident class — word-level refresh — is now proven caught twice (the tester's mid-string edit and my full-sentence replay). If the owner ever wants byte-exact lede pinning, that is a deliberate contract tightening to groom separately; not filed, not needed.

Playwright disposition

The executed-but-wedged playwright component is the documented base condition owned by #193 (engineer's clean-base stash A/B, fix now 572d805 pending merge), and this diff has zero browser surface — deploy/smoke.py, two Django test modules, one allowlist JSON, none read by the browser suite. The tester-final report contains no required skip and no pending screenshot evidence; the absent aggregate report is the known #199 gap, disclosed by both roles. One record correction so my acceptance rests on nothing vacuous: "CI ran playwright green on this exact base" (run 32226341286) is not evidence for this change — that push's selection ran no browser tests. Browser-green for this content arrives with #193's push run, which the ordering below puts directly behind this merge.

Disposition

• Commit keyword: Refs #198 — the deploy-green fact is observable only post-merge. I have added the human label. Remaining check, exactly one: on-call confirms the deploy job promotes on the push run (the re-pinned subtitle serving live). Close Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198 when that green is reported; a failure there reopens it.
• Ordering call: land Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198 first, then Main Playwright suite is red: design-5a batch landed without a browser verdict #193. Main Playwright suite is red: design-5a batch landed without a browser verdict #193's open criterion is its push-run playwright verdict; if Main Playwright suite is red: design-5a batch landed without a browser verdict #193 landed first, its run would inherit the stale smoke pin and redden the deploy job — a 17-minute failed release with rollback, plus a failure on Main Playwright suite is red: design-5a batch landed without a browser verdict #193's run attributable only to unmerged Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198. Landing Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198 first yields a fully green run that closes Re-pin the refreshed homepage subtitle through the deploy contract and fail drift in Django CI #198's remaining check, after which Main Playwright suite is red: design-5a batch landed without a browser verdict #193's run can be green across playwright and deploy alike. The order is technically free — I verified no file overlap between this diff and Main Playwright suite is red: design-5a batch landed without a browser verdict #193's branch — and this change cannot perturb Main Playwright suite is red: design-5a batch landed without a browser verdict #193's playwright verdict. Two sequential pushes happen either way; this order makes both runs meaningful.
• Confirmed along the way: both roles passed VERIFY_ISSUE=198 explicitly (Fail closed on a missing issue number instead of defaulting verification evidence to 113 #197's stale default remains open and disclosed).