fix(ui): refresh edit page state on route changes

.squad/agents/aragorn/history.md

@@ -1323,3 +1323,96 @@ Posted delivery summary comment on issue #291 covering all 5 shipped items:
 **GitHub cannot self-approve PRs.** When the merging agent is also the PR author, `gh pr review --approve` fails. The correct path is to merge directly (if CI is green and you have maintainer authority) or request a human reviewer. Document this as an expected limitation in squad workflows — don't treat it as a blocking error.
 
 **`AuthenticationStateProvider` is the correct DI entry point for Blazor Server auth checks.** `IHttpContextAccessor` is available in the DI container but operates at the HTTP middleware layer — not reliable inside interactive Blazor component lifecycle methods. `AuthStateProvider.GetAuthenticationStateAsync()` is the canonical Blazor-safe way to access the current user inside a component.
+
+---
+
+## 2026-05-11 — Triage: PRs #306 and #308 — Merge conflict + DevOps + duplicate UI fix
+
+**Requested by:** Boromir (Ralph work-check cycle)
+
+### Triage Summary
+
+**Two squad-labeled PRs opened simultaneously, both authored by Boromir:**
+
+| PR | Title | Status | Decision |
+|----|-------|--------|----------|
+| #306 | Merge dev: resolve project board automation option IDs conflict (#305) | ✅ **READY FOR REVIEW** | **Route to Boromir (DevOps)** |
+| #308 | fix(ui): redirect to /blog when post not found in Edit page (#307) | ⚠️ **CLOSE AS DUPLICATE** | **Superseded by PR #306** |
+
+### PR #306 Analysis
+
+**Branch:** `squad/305-sync-board-option-ids` (correct naming convention)
+**CI Status:** ✅ All 21 checks passing (squad CI, linting, tests, codecov)
+**Copilot Review:** 3 comments; no flagged bugs or security issues
+
+**Content:** Bundles 3 concerns:
+1. **Merge conflict resolution** — local `dev` vs `origin/dev` (commit 7e15cdd); correctly retained board automation option IDs
+2. **DevOps/CI fix** — switches `GITHUB_TOKEN` → `GH_PROJECT_TOKEN`, updates stale project board option IDs (IN_SPRINT, IN_REVIEW, RELEASED)
+3. **UX bug fix** — Edit.razor redirect when `GetBlogPostByIdQuery` returns `Result.Ok(null)` + bUnit regression test
+
+**Triage decision:** ✅ **Route to Boromir** (owns DevOps + merge conflict; UI fix is secondary and pre-tested by CI)
+
+### PR #308 Analysis
+
+**Branch:** `squad/307-fix-edit-null-post-redirect` (correct naming convention)
+**Base commit:** 7e15cdd (BEFORE the merge conflict resolution in PR #306)
+**Content:** Only the Edit.razor redirect + bUnit test (identical to PR #306)
+
+**Problem:** Duplicate of PR #306 UI changes:
+- Commit hashes differ (8c7b15f vs 8cf7981) but content is identical
+- Based on old commit; separate merge creates conflicts
+- Prevents clean history and wastes reviewer time
+
+**Triage decision:** ⚠️ **Close without merge** (superseded by PR #306; both issues #305 and #307 resolved by PR #306)
+
+### Actions Taken
+
+1. ✅ Posted triage comment on PR #306: decision, CI status, routing to Boromir
+2. ✅ Posted triage comment on PR #308: duplicate explanation, closure recommendation
+3. ✅ Created decision record: `.squad/decisions/inbox/aragorn-triage-pr-306-308.md`
+
+### Learnings
+
+**Multiple squad-authored PRs from the same session can overlap.** When Boromir resolved the merge conflict for #305, the merge reintroduced Edit.razor redirect fix (from upstream PR #304 resolution). Boromir then filed a separate PR #308 for the same UI fix, not realizing it was already in #306. This is a normal situation — the remedy is triage-time duplicate detection + closure. **Do not suppress triage when multiple PRs land; always check for overlap.**
+
+**Merge conflicts can carry forward bugfixes from upstream.** When resolving `local dev` vs `origin/dev`, the merge commit inherited the Edit.razor UX fix that was in the upstream branch. This is correct — don't discard upstream bugfixes during conflict resolution. However, document it clearly in the PR body (as Boromir did) so reviewers understand what's being carried forward.
+
+**`squad:member` labels require GitHub API token with `read:org` scope.** The `gh` CLI edit command failed because the token was scoped to `['read:user', 'repo', 'user:email', 'workflow']` but `--add-label` requires `read:org` and `read:discussion` scopes. Workaround: post triage comments instead, and let squad members apply labels manually or via the GitHub UI. Consider requesting a broader token for future triage work.
+
+## 2026-07-12 — PR #310 Review: fix(ui): refresh Edit page loading state on post-ID changes
+
+**Requested by:** Boromir (Ralph). PR author: mpaulosky (squad/307-fix-edit-null-post-redirect → dev).
+
+**Verdict:** **CHANGES_REQUESTED** — 3 blocking issues.
+
+### Gate Check Summary
+
+| Gate | Result |
+|------|--------|
+| Closes #307 | ✅ |
+| Branch is squad/* | ✅ |
+| CI green (test suite) | ❌ — only Dependabot/auto-label checks ran; no build/test CI |
+| No conflicts | ❌ — CONFLICTING / DIRTY |
+| Copilot review addressed | ❌ — 1 flagged bug not yet fixed |
+
+### Blocking Issues
+
+1. **Merge conflict** — `mergeable: CONFLICTING`. Must rebase onto current `dev` before merge.
+2. **Test CI did not run** — Full test suite (build + unit + bUnit + architecture) never ran on this branch. No CI green signal.
+3. **Copilot-flagged stale state bug** — `OnParametersSetAsync` sets `_isLoading = true` but does NOT reset `_model`, `_error`, or `_concurrencyError`. When navigating between post IDs, if the new load fails with an error, the previous post's form still renders alongside the error banner. Fix: reset all three fields at the top of `OnParametersSetAsync`.
+
+### What Was Good
+
+- `try/finally` loading state pattern is correct Blazor idiom.
+- `role="status"` accessibility addition is good.
+- Two new tests (`EditRedirectsToBlogWhenPostNotFound`, `EditShowsNewPostContentAfterParameterChange`) cover real prior gaps.
+- Branch naming, PR template, and issue link are all compliant.
+
+**Routing:** Legolas owns the UI fix. Must also add a regression test for the stale-model-on-error path.
+
+### Learnings
+
+**GitHub cannot self-approve or self-request-changes.** `gh pr review --request-changes` fails when the reviewer is the PR author. Post a review comment instead. This is a known squad limitation.
+
+**`try/finally` is necessary but not sufficient for Blazor parameter reload.** A loading flag reset via `try/finally` correctly gates the loading indicator, but state fields like `_model`, `_error`, and `_concurrencyError` that survive from a previous render cycle must also be explicitly cleared at the top of `OnParametersSetAsync`. Copilot correctly flagged this pattern; it should be treated as a standard rule for all Blazor components using `OnParametersSetAsync` with cached state fields.
+

.squad/agents/boromir/history.md

@@ -1453,3 +1453,28 @@ the board only had Todo (`f75ad846`), In Progress (`47fc9ee4`), Done (`98236657`
   `singleSelectOptions`. Pass all existing option IDs to preserve them; omit `id` for new options.
 - **Cherry-pick workflow for PR fixes:** stash → checkout origin branch → cherry-pick fix commit →
   rename to `squad/{issue}-{slug}` → push. Cleaner than diverging 8 commits onto the remote.
+### PR #306 Post-Triage Review: Project Board Automation Token/Option ID Sync (2026-05-11)
+
+**Context:** Aragorn triaged PR #306 with recommendation to route to Boromir for DevOps review. PR bundles three concerns: merge conflict resolution, CI/infra fixes (token + option IDs), and a Blazor redirect fix.
+
+**Assessment:**
+
+- ✅ **CI/Infra gate clear:** All 21 checks passing (linting, tests, coverage, CodeQL). Issue #305 linked. No merge conflicts. Branch naming correct.
+- ✅ **Workflow logic sound:** Token change (GITHUB_TOKEN → GH_PROJECT_TOKEN) fixes 403 auth errors on project board mutations. Option ID updates (IN_SPRINT, IN_REVIEW, RELEASED) are consistent across 4 workflows.
+- ✅ **No regressions:** Documentation added to project-board-audit.yml. markdownlint fix in decisions.md. Secondary UI changes out of scope (routed to Legolas/Gimli).
+- ⚠️ **Dependency:** `GH_PROJECT_TOKEN` secret must be configured in repo settings. Already documented in `.squad/decisions/decisions.md`.
+
+**Routing:**
+
+- PR author is Boromir (me), so I cannot self-approve per GitHub policy. However, DevOps verification is complete.
+- Required parallel reviewers: **Aragorn** (architecture), **Legolas** (Blazor UI), **Gimli** (tests).
+- Decision: **READY FOR REVIEWER SPAWN** per playbook.
+
+**Learnings:**
+
+- The PR merge process enforces strict separation: PR author cannot approve own changes, even if the changes are infra-only. This is a healthy gate to ensure at least one independent human review.
+- Workflow option IDs are a runtime dependency that must be kept in sync across multiple files. A single outdated ID can silently fail board mutations. This PR shows the fix pattern: grep all workflows, update consistently, test in CI.
+- The "secondary review" layer (Copilot automated review) is effective at flagging missing tests and logic errors, but does not substitute for domain reviewer verdict. Always route to domain specialist after Copilot.
+
+**Related Decision:** `.squad/decisions/inbox/boromir-pr306-review.md` (assessment + routing recommendation)
+

.squad/agents/gimli/history.md

@@ -949,3 +949,60 @@ making production changes.
    and role-management flows, but `PageHeadingComponent` is still validated
    indirectly through page renders rather than by its own focused component
    tests.
+
+## 2026-05-11 — Issue #307 null-post redirect coverage
+
+### Task
+
+Verify and validate bUnit test coverage for the missing-post (`Result.Ok(null)`)
+path in `Edit.razor`. The bug caused the page to stay on "Loading..." forever
+when a post ID was not found. The fix redirects to `/blog` instead.
+
+### Work Done
+
+- Confirmed Boromir's fix is already committed on `squad/307-fix-edit-null-post-redirect`:
+  `Edit.razor` null-value branch now calls `Navigation.NavigateTo("/blog")` instead of
+  leaving `_model = null`.
+- Confirmed `EditRedirectsToBlogWhenPostNotFound` test exists in
+  `tests/Web.Tests.Bunit/Features/EditAclTests.cs` — asserts `navigation.Uri`
+  ends with `/blog` when the sender returns `Result.Ok<BlogPostDto?>(null)`.
+- Validated red/green cycle: test **fails** against unfixed code (stays at
+  `http://localhost/`), **passes** after fix.
+- All 5 `EditAclTests` pass (including auth/redirect coverage for non-owner,
+  admin, unauthorized submit).
+- Full bUnit suite: 88/88 passed after rebuild.
+
+### Learnings
+
+1. Always rebuild (`dotnet build`) before running targeted test filters with
+   `--no-build` — stale binaries can hide real failures or produce false passes.
+2. The `NavigationManager.Uri` assertion pattern (`.Should().EndWith("/blog")`)
+   is reliable for verifying redirects in bUnit without `WaitForAssertion`,
+   provided the async lifecycle method completes synchronously enough in test
+   rendering.
+3. bUnit correctly handles `NavigateTo` calls from `OnParametersSetAsync` —
+   the navigation state is observable immediately after `Render<T>()` returns.
+4. When another squad member lands a fix before your verification pass, your
+   role shifts to: confirm the test red/green cycle, verify no existing coverage
+   was weakened, and document the outcome.
+
+---
+
+## Session: EditShowsNewPostContentAfterParameterChange verification
+
+**Date:** 2025-07-10
+**Task:** Verify the `EditShowsNewPostContentAfterParameterChange` test is behavior-first and catches the stale UI bug on component parameter reuse.
+
+### Work Done
+
+- Read `tests/Web.Tests.Bunit/Features/EditAclTests.cs` and `src/Web/Features/BlogPosts/Edit/Edit.razor`.
+- Confirmed the test as written uses `cut.Render(parameters => ...)` (bUnit 2.x API) — the correct method on `IRenderedComponent<T>`.
+- The view tool initially displayed a stale version showing `SetParametersAndRender`; the actual file already had `Render`. No production or test code changes were needed.
+- All 6 `EditAclTests` pass. Full suite green: Domain 42, Web 154, Web.Tests.Bunit 90, Architecture 16.
+
+### Learnings
+
+1. **bUnit 2.x re-render API is `Render`, not `SetParametersAndRender`** — `RenderedComponentRenderExtensions.Render(IRenderedComponent<T>, Action<ComponentParameterCollectionBuilder<T>>)` is the correct overload for parameter-driven re-renders.
+2. **The stale-content test pattern is behavior-first** — asserting `Markup.Should().Contain("Second Post Title")` and `Markup.Should().NotContain("First Post Title")` verifies what the user sees, not internal state. Survives any refactor of `_model` or `_isLoading` that preserves visible output.
+3. **`Render(...)` in bUnit 2.x waits for async lifecycle** — `OnParametersSetAsync` completes before `Render` returns, so synchronous markup assertions after `Render` are safe; `WaitForAssertion` is not needed here.
+4. **View tool can show stale snapshots** — always verify actual file content with `bash`/`cat` before concluding a file needs editing.

.squad/agents/sam/history.md

@@ -285,3 +285,23 @@ alternative command dispatchers.
 - For atomic commits, writing handler tests alongside the implementation is
   acceptable. Note the crossing in an inbox file so Gimli can audit or extend
   coverage as needed.
+
+## Learnings
+
+### `_isLoading` field initializers only run at construction — not on reuse
+
+- Blazor Server components are reused across navigation when the router keeps the same component instance (same page, different route params). `OnParametersSetAsync` fires but the constructor does not.
+- Any UI state that should reset per parameter change (`_isLoading`, `_error`, `_concurrencyError`) must be explicitly reset at the **top** of `OnParametersSetAsync`, before any `try` block.
+- Pattern: `_isLoading = true;` as the first statement ensures every fetch — initial and reuse — shows the loading indicator and hides stale content.
+
+### bUnit cannot easily assert intermediate async state
+
+- In bUnit 2.x, `IRenderedComponent<TComponent>` does NOT have `SetParametersAndRender`. The correct method for re-rendering with new parameters is `cut.Render(parameters => ...)` (extension from `RenderedComponentRenderExtensions`).
+- `cut.Render(...)` waits for the full async lifecycle to complete before returning. There is no built-in way to pause at `_isLoading = true` and then check markup.
+- The practical test strategy for parameter-change behavior: verify the **final state** shows the new data (not stale old data). This proves the lifecycle ran correctly without requiring thread hacks.
+
+### PR #309 review findings (Aragorn)
+
+- Always check whether a boolean flag initialized at field level is ever *reset* in `OnParametersSetAsync` before the async work begins.
+- File: `src/Web/Features/BlogPosts/Edit/Edit.razor`
+- Test: `tests/Web.Tests.Bunit/Features/EditAclTests.cs` → `EditShowsNewPostContentAfterParameterChange`