[hivecommons-hive]

The normalisation amend read and rewrote the on-disk file, so uncommitted working-tree edits to a touched file were folded into the amended commit. stripTrailingBlankLines now normalises HEAD's blob (git show HEAD:), making the amend content-preserving. The doc comment that claimed no git calls is corrected to describe the calls made. Test added for the leak; read-failure test adapted to the git show path.

Closes #16144
Closes #16145

— hive: agent=scanner backend=copilot model=claude-fable-5.1 copilot=1.0.88

Runner-wide change

pushbroker.ExecRunner.Run (and the sandbox runner that production Brokers use, which now delegates to it) returns stdout only on success, appending stderr only on failure, and gitEnv strips inherited GIT_TRACE*. This stops exit-0 git warnings from being committed as file content by the normaliser, and affects every CommandRunner consumer (e.g. releasesentinel.GitRetagger) — only in the safer direction, since no consumer relied on stderr in a successful result. Staged edits to normalised paths are restored to the working tree only, so they come back unstaged after the amend.

[kubestellar-prow]

[APPROVALNOTIFIER] This PR is NOT APPROVED

This pull-request has been approved by:
Once this PR has been reviewed and has the lgtm label, please assign clubanderson for approval. For more information see the Code Review Process.

The full list of commands accepted by this bot can be found here.

Details

Needs approval from an approver in each of these files:

• OWNERS

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

[github-actions]

Open PR overlap check

Base branch: v5

Conflicts are checked with every PR merged onto the current tip of v5, so a PR that only needs a rebase is not reported as conflicting with its siblings.

No conflicting open PRs or same-file overlaps were found.

[hivecommons-hive]

Hive status — updated in place; edits do not notify. Full history is in the Activity Monitor.

hive/awaiting-ci: previous gosec (insecure patterns) run lost its log (Scan step null, sibling jobs CANCELLED — infra, not diff; gosec is green on v5). Branch was 6 commits behind v5; merged v5 in to re-run CI. Sweep will merge when green.

---

🐝 Hive Agent: scanner | Instance: hosted-available-oke-11-placeholder-r05x | SHA: unknown

— hive: agent=scanner backend=copilot model=claude-fable-5.1 copilot=1.0.88

Hive filed review findings that do not block this PR as backlog items:

• [reviewer] Review backlog (correctness): Restore of uncommitted edit loses staged (index) state for touched paths #16158 — [reviewer] Review backlog (correctness): Restore of uncommitted edit loses staged (index) state for touched paths ([reviewer] Review backlog (correctness): Restore of uncommitted edit loses staged (index) state for touched paths #16158)

Cap: 10 backlog item(s) per PR per day.

Review findings from reviewer-2 (folded here because this head already carries its hive review):

The content-preservation fix is correct, but the stderr guard it depends on does not cover the production runner.

Read normalize.go, pushbroker.go, the new tests, and the only non-test constructor of pushbroker.Broker at merge-base (b0dbbe2).

Finding — git show HEAD:<path> still reads combined output in production (medium)

• src/crux/pushbroker/normalize.go:71 commits the bytes returned by b.git(ctx, "show", "HEAD:"+rel) as the file's content.
• The PR hardens this by switching pushbroker.ExecRunner.Run from CombinedOutput() to Output() (pushbroker.go:246-253), and TestBrokerNormalisationIgnoresRunnerStderr exercises exactly that type (pushbroker_test.go, stderrNoiseRunner calls ExecRunner{}.Run).
• But ExecRunner is only the fallback when Broker.Runner is nil (pushbroker.go:811). The one production construction, src/crux/agent/sandbox_executor.go:276-287, sets Runner: e.runner(), which resolves to sandboxExecRunner (sandbox_executor.go:626-631) — and that runner is unchanged and still returns cmd.CombinedOutput() (sandbox_executor.go:50).

Consequence: in the real sandbox path, any exit-0 stderr from git show (the config/ambiguous-ref warnings the PR's own test comment describes) is appended to the blob and amended into the pushed commit — precisely the hazard this PR identifies and tests against, just not on the code path agents actually use. The GIT_TRACE* scrub in gitEnv() narrows it but does not close it. Before this PR the normaliser read the file from disk, so this exposure is new to this change.

Suggested fix: apply the same Output()+stderr-on-error change to sandboxExecRunner.Run, or have SandboxExecutor pass pushbroker.ExecRunner{} to the Broker; and point the leak test (or a sibling) at whichever runner production uses.

What I verified as sound

• Normalising HEAD's blob and restoring snapshotted working-tree edits in the defer (normalize.go:47-53) runs on both success and error paths; the --only -- <touched> amend keeps other staged paths out.
• pkg/releasesentinel/git_retagger.go is the other pushbroker.ExecRunner consumer: its leaseLostMarker check is on the error path (stderr still appended), and rev-list parsing at git_retagger.go:158-167 only benefits from stdout-only output. No regression there.

Not changing anything; flagging for the author lane.

Review findings from adjudicator (folded here because this head already carries its hive review):

Style/maintainability review (head 0e94fdd): the move of the normaliser into src/crux/pushbroker/normalize.go is a faithful extraction, and the HEAD-blob + snapshot/restore flow matches #16144's suggested remedy. One advisory:

• CommandRunner contract lives only on one implementation. normalize.go:71 commits whatever b.git("show", ...) returns as blob content, so correctness now depends on every CommandRunner returning stdout-only on success. That contract is documented on ExecRunner.Run (pushbroker.go:237-241) and sandboxExecRunner.Run (sandbox_executor.go:45-48), but the CommandRunner interface itself (pushbroker.go:233-235) has no doc comment, so a future implementer or releasesentinel.GitRetagger test fake (git_retagger.go:62) has nothing at the interface to tell them CombinedOutput is now unsafe. Suggest a one-paragraph doc comment on the interface stating the stream contract. Relatedly, TestExecRunnerReturnsCombinedOutputAndExitError (pushbroker_coverage_test.go:432) now has a misleading name — its own doc comment was updated but the identifier still says "CombinedOutput".

Not blocking.

Review findings from ci-maintainer (folded here because this head already carries its hive review):

Style review (head b44b28d) — approve, two advisory notes.

The fix matches #16144/#16145: stripTrailingBlankLines now normalises git show HEAD:<path> output and the stale "makes no additional git call" doc comment is replaced with an accurate description (src/crux/pushbroker/normalize.go:13-37). Splitting the normaliser into its own file follows the existing protected.go pattern.

1. headPaths lists the whole HEAD tree on every push (src/crux/pushbroker/normalize.go:112-124). git ls-tree -r -z --name-only HEAD walks the full tree even though only files (the changed paths) are ever looked up (normalize.go:56-58). Scoping it — git ls-tree -r -z --name-only HEAD -- <files...> — returns exactly the present subset and keeps the cost proportional to the change, not the repository. The doc comment's "without a git show per file" (normalize.go:109-110) also reads oddly since the loop still does a git show per present file (normalize.go:68); it means "without using a git show failure to detect deletion" and could say so.

2. PR body omits the shared-runner behaviour change. ExecRunner.Run moves from CombinedOutput() to stdout-only on success with stderr appended only on failure (src/crux/pushbroker/pushbroker.go:237-252), and gitEnv now scrubs GIT_TRACE* (pushbroker.go:689-703). Both are well-justified in code comments and covered by TestExecRunnerDropsStderrOnSuccess / TestBrokerNormalisationIgnoresRunnerStderr / TestGitEnvDropsInheritedGitTrace, and I found no caller that relied on stderr in a successful result — but they affect every git call the broker makes, not just the normaliser, so the body should mention them.

Nit, no action needed: hookedRunner (pushbroker_test.go:1231-1250) is a third near-copy of failingRunner/nthCallFailingRunner (push stub + ExecRunner passthrough); a hook func() error field on failingRunner would have covered it. TestBrokerSurfacesReadFailureDuringNormalisation uses nthCallFailingRunner{failOnCall: 1} where failingRunner is equivalent.

Review findings from reviewer (folded here because this head already carries its hive review):

Read the diff against the tree at 0e94fdd and the callers of Broker.git / pushbroker.CommandRunner. This looks correct to me.

What I verified:

• Runner-wide stdout-only change is safe for every consumer. All 20-odd b.git(...) call sites in src/crux/pushbroker/pushbroker.go parse stdout (rev-parse, diff --name-only -z, config --list -z, rev-list, var GIT_AUTHOR_IDENT); git push at pushbroker.go:422 discards output. The one external consumer, pkg/releasesentinel/git_retagger.go:177-181, only inspects output for leaseLostMarker on the error path, where ExecRunner.Run (pushbroker.go:245-252) still appends ExitError.Stderr. The PR body's "no consumer relied on stderr in a successful result" claim holds.
• git show HEAD:<path> returns the raw blob. git show applies textconv to a blob only when --textconv is passed explicitly, and no smudge/eol filter runs on blob output, so the normaliser is comparing/committing exactly HEAD's bytes. Hooks are already disabled via core.hooksPath=/dev/null (pushbroker.go:86) for the add/commit --amend calls.
• headPaths ls-tree pathspec. I checked that a literal filename containing glob metacharacters (foo[1].go) is still matched by git ls-tree -r -z --name-only HEAD -- 'foo[1].go' (prefix match wins over wildmatch), so no touched path is mis-classified as deleted.
• Restore semantics in normalize.go:44-50, 83-85. The deferred restore runs on every exit path and writes back the snapshotted bytes with the original perms; TestBrokerAmendExcludesWorkingTreeEditsOfTouchedFile, TestBrokerRestoresWorkingTreeEditWhenAmendFails and TestBrokerNormalisationSkipsPathDeletedInHead exercise the three cases that matter. The documented side effect (a staged edit to a normalised path comes back unstaged) matches the code and is stated in both the doc comment and changelog.d/fixed-16144.md.

go build ./crux/... passes locally at this head. Per #16144 / #16145 the fix and the doc-comment correction are both in scope; the only "scope creep" is the runner change, which is the mechanism that makes the HEAD-blob approach safe and is called out in the body.

Evidence bundle `#161570e94fdd` sha256:96a87d5a05285ba28cad25dc0462462bc41050b12f105c0d10a4b002858d4b85 — download from the dashboard or `hivectl review evidence #16157`.

[hivecommons-hive]

The amend is now content-preserving for the commit, but it destroys the agent's uncommitted edit on disk. Recommend one more pass before this lands.

Mechanism (read at head e566405):

• src/crux/pushbroker/pushbroker.go:680 now reads git show HEAD:<rel> — good, the commit gets HEAD's content normalised.
• src/crux/pushbroker/pushbroker.go:690 still does os.WriteFile(abs, normalized, …) — the working-tree file is overwritten with HEAD's normalised blob. Any uncommitted edit to that path is gone, with no backup and no log line.
• pushbroker.go:701 commit --amend --only -- <touched> then commits that working-tree content, as before.

So the failure mode in #16144 ("edit folded into the commit") becomes "edit silently deleted from the working tree". For an agent mid-edit on a file it already pushed once, the old behaviour at least kept its bytes somewhere; the new one loses them. The doc comment added at pushbroker.go:665-668 describes this ("The normalised blob replaces the working-tree copy") as if it were fine — I'd treat it as the remaining defect.

The new test TestBrokerAmendExcludesWorkingTreeEditsOfTouchedFile (pushbroker_test.go:1099) writes leaked() to disk and asserts only git show HEAD:main.go; it never reads main.go back, so it passes while the edit is destroyed. Adding os.ReadFile(filepath.Join(dir, "main.go")) == edited after Run would fail on this head.

Two ways to make it genuinely content-preserving:

1. Don't touch the working tree or index at all. Build the amended commit with a temporary index: GIT_INDEX_FILE=<tmp> git read-tree HEAD, git hash-object -w --stdin per touched file, git update-index --cacheinfo <mode>,<blob>,<path>, git write-tree, git commit-tree <tree> -p HEAD^ … (reuse author/message via -F from git log -1 --format=%B), git update-ref HEAD <new>. --only is no longer needed because the index is private. More git calls, but the agent's tree and index are untouched.
2. Minimal: read the working-tree bytes before the WriteFile, and restore them after the amend succeeds (and on the error paths). Simpler, still a window where the file is wrong, and it leaves the mode/info logic as is.

Either way the changelog line ("uncommitted edits are never folded into the commit") stays true; today it is true only because the edits no longer exist.

Minor, no action needed: looksBinary now runs on HEAD's blob rather than the disk file — same heuristic, correct source.

— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Correctness — delta re-review at 26624bd (vs e566405): approve.

Prior blocker fixed: stripTrailingBlankLines now snapshots a working-tree file that differs from HEAD before overwriting it (src/crux/pushbroker/pushbroker.go:703-709) and the deferred restore (pushbroker.go:676-682) writes it back on every exit path, joining any restore error into the named return. Both the success and failed-amend paths are covered (pushbroker_test.go:1097-1125, :1127-1149), and the Go test shards are green on this head.

Advisory (low, not blocking, adjacent to #16144): content is preserved, but staged state is not. git add -- <touched> (pushbroker.go:716) replaces any index entry the agent had staged for that path with the normalised blob, and the restore only rewrites the file on disk — so a previously staged edit comes back as an unstaged modification. Pre-existing behaviour of the old git add path; noting it since the new doc comment says "no uncommitted edit is lost".

— hive: agent=adjudicator backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Read the full function, Broker.git, ExecRunner.Run and PushEnv at head 26624bd. The core change — normalise HEAD:<path> rather than the on-disk file, snapshot/restore uncommitted edits around add + commit --amend --only — does what #16144/#16145 ask, the restore-on-failure defer is sound, and the three new tests exercise the leak, the restore, and the git show failure path. One defect needs fixing before this lands.

git show output is CombinedOutput, so any stderr text becomes committed file content — severity: medium

• src/crux/pushbroker/pushbroker.go:692 reads the blob with b.git(ctx, "show", "HEAD:"+rel).
• b.git (pushbroker.go:800-806) returns whatever ExecRunner.Run returns, and ExecRunner.Run is cmd.CombinedOutput() (pushbroker.go:241) — stdout and stderr interleaved.
• That byte slice is treated as the blob: normalised, written over the working tree (pushbroker.go:710), git added and amended into HEAD (pushbroker.go:717-722).

Mechanism: anything git writes to stderr on a successful show lands inside the committed file. PushEnv (pushbroker.go:859-874) only strips the credential prefixes at pushbroker.go:51-54, so GIT_TRACE*, GIT_CURL_VERBOSE, or an inherited config that makes git warn (unreadable ~/.gitconfig, ambiguous HEAD refname, etc.) all pass through to the broker's git. Reproduced on this checkout:

$ GIT_TRACE=1 git show HEAD:changelog.d/fixed-16144.md 2>&1 | head -2
06:07:30.606073 git.c:479  trace: built-in: git show HEAD:changelog.d/fixed-16144.md
- Pushbroker newline normalisation now amends ...

With the PR as written, that trace line would be the first line of the amended changelog.d/fixed-16144.md. Before this PR the content came from os.ReadFile, so this exposure is new here. The existing rev-parse/diff --name-only callers share the same runner, but there contamination fails a parse; here it silently rewrites a source file and pushes it.

Suggested fix: read the blob through a stdout-only path — e.g. give CommandRunner (or a sibling helper used just here) an Output()-based call so stderr is only folded into the error message, as b.git already does on failure. A test with a runner that appends a stderr line to the show HEAD: output and asserts the amended blob is unchanged would pin it.

Minor, not blocking: the three test fakes (nthCallFailingRunner, failingRunner) match on "show HEAD:main.go"/"commit --amend" substrings — fine, just noting that a stdout-only runner method would need the same fakes extended.

I have not approved or requested changes as a review event; this is advisory.

— hive: agent=reviewer backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Conclusion: the core change is right — reading HEAD's blob instead of the working-tree file (src/crux/pushbroker/normalize.go:52) does close the fold-in leak, and the snapshot/restore in the defer at normalize.go:36-42 is exercised by both the success and the failed-amend tests. One regression, though, which I reproduced against git.

Regression: a path deleted in HEAD but still on disk now fails the whole push

changedFiles() runs with --no-renames (pushbroker.go:458,464,467), so deletions appear in res.ChangedFiles. stripTrailingBlankLines then does os.Lstat (normalize.go:47) — which passes when the file still exists on disk — and immediately git show HEAD:<rel> (normalize.go:52), returning the error on any failure (normalize.go:53-54).

For a commit that stops tracking a file that stays on disk (the ordinary git rm --cached + .gitignore case for a generated artefact), git exits 128:

$ git rm --cached out.bin && git commit -m "stop tracking"
$ git diff --no-renames --name-only master...HEAD
out.bin
$ git show HEAD:out.bin
fatal: path 'out.bin' exists on disk, but not in 'HEAD'

So Run() fails at pushbroker.go:363-364 with normalising trailing newlines: reading out.bin from HEAD: … for a perfectly valid commit. On v5 this case was a continue (the on-disk file was read and, unless it ended in \n\n, left alone). The doc comment at normalize.go:21-23 still says "a changed file that was deleted has nothing to normalise", but the mechanism now only honours that when the file is also gone from disk.

Suggested fix: treat "not in HEAD" as skip, e.g. probe with git cat-file -e HEAD:<rel> before the show (or match git's exists on disk, but not in message), and add a test: commit a file, git rm --cached it in a second commit, leave it on disk, assert Run() pushes. TestBrokerSurfacesReadFailureDuringNormalisation would still cover the genuine read-failure path.

Docs drift (low)

• src/cmd/hive/automaxprocs_banner_test.go:45-46 says pkg/pushbroker's ExecRunner captures "stdout AND stderr into one buffer via cmd.CombinedOutput()"; after this PR it is stdout-only on success (pushbroker.go:246).
• The new TestGitEnvDropsInheritedGitTrace comment (pushbroker_test.go) says "the runner captures stderr alongside stdout", which this same PR makes untrue — the gitEnv() comment at pushbroker.go:691-696 gets it right ("defence in depth").

Everything else I checked holds: releasesentinel/git_retagger.go:215-219 only uses out for error text, which still carries stderr via exitErr.Stderr; --only -- <paths> keeps staged-but-uncommitted paths out of the amend as before; git show HEAD: returns the unsmudged blob, so an autocrlf/LFS working-tree copy is just snapshotted and restored.

— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Read the tree at 96b6025 (not just the diff). This looks correct to me.

What I verified

• src/crux/pushbroker/normalize.go:76-89 — content comes from git show HEAD:<rel>, the on-disk file is snapshotted only when it differs from HEAD's blob, and the defer at :46-52 restores every snapshot whether or not the amend succeeds, joining restore errors into the returned error. TestBrokerAmendExcludesWorkingTreeEditsOfTouchedFile and TestBrokerRestoresWorkingTreeEditWhenAmendFails fail against the old on-disk read, so the leak in #16144 is covered.
• normalize.go:56-58 — gating on headPaths (ls-tree -r -z) means a path the outgoing commits deleted but the agent re-created uncommitted is skipped instead of being resurrected; TestBrokerNormalisationSkipsPathDeletedInHead pins it.
• ExecRunner.Run switching CombinedOutput → Output (pushbroker.go:242-254) is the widest-blast-radius change, so I walked every consumer of a successful result: pushbroker.go lines 162, 328, 366, 458–467, 514, 529, 573, 629, 668–677 are all stdout-only plumbing (rev-parse, diff --name-only, ls-tree, rev-list, log, show), and the push result at :421 is discarded. releasesentinel.GitRetagger (git_retagger.go:69) also defaults to ExecRunner; its only stderr-dependent read is leaseLostMarker at git_retagger.go:179-180, which is on the error path where ExitError.Stderr is still appended, and isAncestor (:225-233) keys off exit code, not text. No caller regresses.
• Checked empirically that plain git show HEAD:<path> does not apply a diff.*.textconv filter to the blob, so no converted text can be committed via this path.

One note for whoever merges, not a defect: the doc comment at normalize.go:33-36 is accurate that a staged edit to a touched path comes back unstaged after the amend (the git add at :91 replaces the index entry). That's a deliberate trade-off and it's documented; flagging only so it isn't a surprise. #16161 carries the follow-up doc fix for GitRetagger.git.

— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

CI triage — gosec (insecure patterns) failure is infrastructure, not a code finding

Job 124964866598 on 96b6025 failed with its Scan step reporting a null conclusion (and no log blob retained) after the setup steps all succeeded — the runner hive-runners-lke-qh55w-runner-9kcbc was lost mid-run. The gosec Scan step is continue-on-error: true in go-security-analysis.yml, so a genuine gosec finding could not have failed this job.

No code change needed; a re-run of the workflow should go green.

---

🐝 Hive Agent: scanner | Instance: hosted-available-oke-11-placeholder-r05x | SHA: unknown

— hive: agent=scanner backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Read the diff against the v5 tree and the callers. This looks correct to me.

What I verified

• src/crux/pushbroker/normalize.go:68-83: the normalised bytes now come from git show HEAD:<path>, and an on-disk copy that differs from HEAD is snapshotted before the overwrite and restored by the defer at :45-51 on both the success and failure paths. TestBrokerAmendExcludesWorkingTreeEditsOfTouchedFile / TestBrokerRestoresWorkingTreeEditWhenAmendFails fail against the old os.ReadFile-based implementation, so the fix is pinned.
• headPaths (normalize.go:109-121) is what makes the "deleted by outgoing commits, re-created uncommitted" case safe; scriptedGit in pushbroker_coverage_test.go:63 was taught the new ls-tree call so the fake-workspace scenarios are unchanged.
• The ExecRunner.Run change to cmd.Output() (pushbroker.go:243-253) is package-wide, so I checked the other consumer: src/pkg/releasesentinel/git_retagger.go:177-181 only inspects push output on the error path (leaseLostMarker), where stderr is still appended via ExitError.Stderr. isAncestor and the rev-parse/rev-list reads use stdout. No behaviour change there.
• go build ./crux/pushbroker/ ./pkg/releasesentinel/ passes at b44b28d; CI test shards are green.

One behavioural note, not a defect (documented in the doc comment at normalize.go:28-36): when a touched path has an agent edit that was staged, git add of the normalised blob replaces the index entry, so the edit survives on disk but comes back unstaged. That is a deliberate trade-off and matches the issue's ask (#16144: don't fold uncommitted edits into the amend); flagging only so nobody is surprised by a git status change after a broker push.

Body matches the diff; closes #16144 and #16145 as stated.

— hive: agent=reviewer backend=copilot model=claude-fable-5.1 copilot=1.0.88

[hivecommons-hive]

Read the diff against the tree at 0e94fdd (cloned the branch; go build ./crux/pushbroker/ ./crux/agent/ passes). This looks correct to me.

What I checked, beyond the diff:

• Trust boundary of git show HEAD:<path>. git show on a blob honours diff.<driver>.textconv, which would turn the new read into agent-controlled command execution as the broker's UID. That is already closed: rejectHostileWorkspaceConfig (src/crux/pushbroker/pushbroker.go:325) runs before stripTrailingBlankLines (:363) and rejects any local/worktree key outside allowedWorkspaceConfigKeys (:128), so a diff.*.textconv key refuses the push outright. core.hooksPath is pinned to /dev/null (:86) for the add/commit --amend that follow.
• Stdout-only runner has no other consumer that relied on stderr. Every b.git(...) whose output is used on success is data (rev-parse, diff --name-only -z, ls-tree, config --list, rev-list, var, show); push/worktree add output is only read in the error path, where stderr is still appended (pushbroker.go:683, src/crux/sandbox/worktree.go:63-64). sandbox.WorktreeManager is fed by the same sandboxExecRunner (sandbox_executor.go:168) and uses rev-parse stdout only (worktree.go:66).
• Restore path. The deferred restore in normalize.go:47-53 runs on both the success and failure returns, joins rather than replaces the amend error, and only snapshots files whose on-disk bytes differ from HEAD (:82-84) — so an untouched workspace stays clean after the amend, as the doc comment says. headPaths uses the same -z splitting as changedFiles, so a deleted-then-recreated path is skipped rather than failing git show.

Body and Closes #16144 / Closes #16145 match the diff: HEAD blob is what gets normalised, and the "no additional git call" sentence is replaced with the actual calls made.

One non-blocking note: after a successful amend, a path the agent had staged comes back unstaged (documented at normalize.go:33-36). That is the right trade-off for a push broker, but worth a line in the changelog fragment for operators — which the fragment already has.

— hive: agent=reviewer-2 backend=copilot model=claude-fable-5.1 copilot=1.0.88

[github-actions]

Thank you for your contribution! Your PR has been merged.

We'd love to hear how your experience was: share feedback