Skip to content

fix(members): order the Recent roster by the crew log, and record the user's own send - #15277

Merged
iamwhatever merged 1 commit into
mainfrom
fix/roster-recency-from-crewlog
Sep 30, 2026
Merged

iamwhatever merged 1 commit into
mainfrom
fix/roster-recency-from-crewlog

Conversation

@chenmingwei23

@chenmingwei23 chenmingwei23 commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: Sorted by Recent, the crewmate you just messaged moves to the top of the Crewmates roster, live.

It did not. Reproduced 2026-09-30: roster sorted by Recent, typed into a crewmate's DM, the row stayed in the middle of the list, in the alphabetical position it had before the send. The one crewmate the user is actually talking to was the hardest one to find.

Why it matters

Recent is the roster's default sort and the list is the only way into a crewmate's thread. A Recent sort that does not react to the user's own message is worse than no sort: the user has a mental model of "the one I am talking to is at the top", acts on it, and lands on someone else's durable pinned thread. The same staleness reaches resolveDefaultMember, which opens the most recently used chat on a return visit, so a recency that never advanced sends the user back to the wrong conversation. A crewmate bound mid-session (its memory-store generation is minted at the moment of the first message) had no recorded activity at all and fell to the alphabetical tail.

Not a goal

  • Changing the sort vocabulary, adding a sort, or changing which sort is the default.
  • Relaxing the order hold for a background refetch. Re-sorting on a passive refetch moves rows under the cursor mid-click, which Crew Members roster re-sorts under the cursor on every refetch after the React Query migration #9524 fixed; that behaviour is preserved deliberately.
  • Changing where the roster's last_message preview comes from. The transcript stays its authority, for the reason the reconcile documents.
  • Making the member/message append reliable. It stays a best-effort hook; this PR makes a dropped append lose nothing rather than making it not drop.
  • Any change to how a member DM slot is minted, bound, or authorized.

What changed (motivation -> approach -> change)

Four independent causes, each alone enough to hold the row still.

1. The user's own send recorded nothing. The member/message event the roster's last_active_ts folds from was emitted at the tail of DashboardState._broadcast_chat_message. Slot.append calls that hook only when (role != "user" or broadcast_user) and not self._has_reader, and the dashboard composer appends the user row with broadcast_user defaulting to False (chat_handlers.py) because the composer already drew its own bubble. That gate answers does anything still need to render this row, which says nothing about did this row happen -- so the single action the user most expects to reorder the roster emitted no event, and the _has_reader arm lost assistant rows the same way.

The emit moves out to DashboardState._record_member_row, wired as a new Slot._on_row hook and called from Slot.append for every live row. It shares only the two conditions that make a row not a row: the wire-only roles (chunk / done / streaming, none of which is persisted) and broadcast, which is what separates a live append from a replay (channel_slots._rebuild_window, chat_fork, session_transfer). Recording a replay would stamp a member as active just now for a message sent hours ago and reorder the roster on a rotation recovery.

2. The roster read did not consult the fold. GET /api/members set row["last_active_ts"] from the DM transcript's last SPEECH row, which answers when did this member last say something rather than when was it last active -- so a machinery turn was invisible to the ordering, and so was a row appended but not yet flushed. _recency_for_row now reads the response's own folded roster projection and returns max(folded, transcript). The fold is the authority; the transcript is a FLOOR, because these events ride a best-effort hook a queue ceiling may drop and a member whose log cannot answer (no log yet, a slug shared by two members, a read the store will not prove -- each answers an empty values) has only the transcript. Because the row and the projection block it ships now carry one value, the client's higher-seq-wins merge has one reading to reconcile rather than two.

3. The preview reconcile walked recency backwards. reconcile_member_preview corrects a stale quote by appending a member/message carrying the TRANSCRIPT's epoch -- the last thing said, older than any machinery turn since -- and RosterProjection took each event's ts last-wins. So even a correct fold was reset to the last speech on every roster read, in an append-only log with no compaction and nothing to reopen it. This is why reading the fold in the handler was not sufficient on its own. last_active_ts becomes the one monotone field in that fold: time only moves forward, so a fold that moved it down could only ever be wrong. _parse_ts normalises first, so an ISO string folds to epoch seconds and a None, a bool or a non-number leaves the held value alone instead of becoming an ordering key. RosterProjection.state_version goes to 2 in the same step, because monotonicity is bookkeeping a savepoint written WITHOUT it can contradict: such a savepoint can hold a recency a preview correction walked backwards, and a resume applies only the events after it, so the regressed value would stand for the life of the store (or until the member next spoke) and the Recent order would still be wrong after the upgrade. A state_version mismatch discards the payload, after which the member's own log is re-folded from the start -- the events the bad savepoint consumed are the ones that hold the truth.

4. The client could not let a live frame move a row. MembersPage merged the pushed projection's last_active_ts only when the row carried none (if (!r[key])), so a frame could never move a row that had any recency; and orderedMembers committed the order per membership + sort and never re-sorted on an advance. Recency now merges as the GREATER of row and pushed frame -- monotone, so a baseline frozen at its seed sequence cannot regress a row -- and orderedMembers reacts to one more event: the OPEN crewmate's recency advancing. That is not a background event; the open crewmate's recency can only move because of what the user just did in the thread in front of them. It lifts that one row out of the committed order and puts it first, rather than re-sorting -- a whole re-sort would publish every recency that arrived since the order was committed, so a background crewmate that advanced quietly during the visit would jump too, the hold would be spent, and rows WOULD move under the cursor. The other rows keep their positions relative to each other, which is also what the user's model says happened: I messaged this crewmate, so this crewmate is first. It settles after one move, since a row already first is not lifted again. Recency-ordered only: under the by-name sort a recency advance says nothing about where a row belongs, so the lift does not run. A row merely BECOMING the open one re-baselines the reading without moving anything, so opening a member still never shuffles the list.

The spec (docs/system-specs/modules/member-event-log.md) is updated in the same commit: the member/message emitter, the monotone field, and the roster read's authority.

Backwards compatibility

Compatible. No field is added, renamed, removed or narrowed, and no reader is given a value it could not already receive: last_active_ts was already an optional number on the roster row and in the roster projection view, and both changes only ever move it FORWARD in time. RosterProjection.state_version moves 1 -> 2, which RETIRES every existing roster savepoint: they are a cache of the member's own append-only log, so each is rebuilt by one cold fold on next read and nothing is lost. That is a deliberate one-time re-fold, not a compatibility break -- the savepoint kernel already treats a discarded payload as an ordinary outcome (projection/checkpoint.py), and no caller is served anything that depends on one existing. The member/message event shape is unchanged; the only difference is that more of the rows that always existed now produce one.

Two behaviours deliberately change, both in the direction of recording more:

  • A user row in a member DM, and any row on a slot with an HTTP stream reader, now produce a member/message. That is the fix.
  • A stop-card re-broadcast (_resolve_stop_event / _rearm_stop_event call _on_message directly on an existing row) no longer produces a second member/message. It never was a new message, so it was a duplicate recency bump.

Tests

test/test_members_roster_recency.py, 22 cases:

  • TestRecencyForRow -- the fold wins over an older transcript; the transcript floors a lagging fold; an empty values falls back to the transcript; a None / ISO string / bool / negative / NaN fold is not an ordering key (True in particular must not rank a member one second after the epoch, since bool is an int subclass).
  • TestTheFoldNeverWalksRecencyBackwards -- a preview correction keeps the newer recency and still lands its quote; a newer event still advances; an event with no ts leaves it alone; an ISO ts normalises to a float. Plus the retirement itself: state_version must be at least 2, without which every pin above holds only for a store that has never saved.
  • TestRosterReadTakesTheFoldedRecency -- end to end over GET /api/members: a machinery turn newer than the last speech orders the row, the preview still comes from the transcript, and the row agrees with the projection block it ships; a member with no log keeps the transcript reading.
  • TestAppendRecordsTheRow -- a user row from the composer IS recorded (the bug); an assistant row is recorded even with a stream reader; a replay is not; the wire-only roles are not; a failing recorder does not break the send.

website/src/pages/members/MembersPage.test.tsx -- "the OPEN crewmate rising to the top is the one recency change that re-sorts": opening the coldest row does not re-sort, a background crewmate advancing QUIETLY to the greatest recency of the three moves nothing, a pushed member_projection frame for the open row then puts THAT row first with zero api.members calls -- not the higher-ranked background row, which is what a whole re-sort would have done -- and the other two keep their order relative to each other. A second case pins the by-name sort: there, the open crewmate's own advance moves nothing at all. The existing "a refresh-frame refetch never reorders the roster" case is unchanged and still passes, which is what holds cause 4's other half.

website/scripts/record-members-recency-move.mjs drives the isolated capture entry
(website/capture/members-page.html, which mounts the REAL MembersPage gateway-free) and asserts the
recording's own claim before writing it: the cold row starts below the others, opening it reorders
nothing, a background crewmate's quiet advance to the top recency moves nothing, a pushed projection
frame then puts the OPEN row first and leaves the other two in their relative order, and
the roster-fetch count is unchanged across the move -- with a control asserting that counter observes a
real fetch at all, since a handler shadowed by the shared stub would otherwise read 0 forever.

Each fix is mutation-proved: nine mutations, one per decision, all nine caught by the case that claims to pin them, over a control run that was green first. Local runs: 22 pytest + 94 pytest across the three adjacent suites that touch the moved emit, 265 vitest across the three members files. flake8 / isort / black / mypy clean on the touched modules.

Manual verification

End to end in an isolated pod on this worktree (kirocrew pod up kc-wt-roster-recency), driving the real endpoints and the real UI: three crewmates seeded so the Recent order is not alphabetical, then the coldest one opened and messaged.

reading before the send after the send
roster order gamma-writer, alpha-scout, beta-lead beta-lead, gamma-writer, alpha-scout
beta-lead row last_active_ts 1790740235 1790740281
beta-lead folded projection last_active_ts 1790740235 1790740281
api.members refetches driven by the move 0

The row and the fold agree on both readings, and the move is carried by the projection push alone.

Screenshots / video

The move itself, recorded. beta-lead is the open row (highlighted) and sits third under Recent; the user's own send arrives as a pushed member_projection frame and the row travels to the top, with framer's layout carrying it so the eye can follow. Then a BACKGROUND crewmate's recency advances and nothing moves, which is the order hold still doing its job. Zero roster refetches drove any of it.

Recent sort: the open crewmate's row moves to the top on the user's own send

Stills of the same behaviour end to end in a real pod (a gateway, a real DM, a real agent turn), where the numbers in Manual verification were read:

Pod stills, before and after the send

Pod: before the send, beta-lead open and third

Pod: after the send, beta-lead first

Related Issues

Closes #15276

Pattern harvest

Rule candidate: review-prompt
Pattern: a durable record written from inside a DELIVERY hook, so a row that needs no rendering is also never recorded. The two questions -- does anything still need to render this, and did this happen -- have no conditions in common beyond the row not existing, and hanging the second off the first silently drops exactly the rows some surface already drew optimistically.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@chenmingwei23
chenmingwei23 requested a review from a team September 30, 2026 04:02
@chenmingwei23
chenmingwei23 requested a review from a team as a code owner September 30, 2026 04:02
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Sep 30, 2026
@github-actions

github-actions Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — 🟡 CONCERNS

Design-level review of a164a9538cde0be17af96aa07bd2fbf2e76f5d8a — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: CONCERNS

Monotone recency has no ceiling: one forward-skewed timestamp pins a member atop Recent for the store's life, and last-wins's self-healing is gone.

Watch

The fold's premise — "time only ever moves forward, so a fold that moved it down could only ever be wrong" (members_projections.py) — holds for real activity but not for the recorded sample: _record_member_row stamps time.time() and _parse_ts folds any ISO string, so a clock jump (VM resume, NTP correction) writes a far-future last_active_ts that ts > held then rejects every correction of, _recency_for_row's max() propagates to the roster, and resolveDefaultMember keeps opening that member. Under the old last-wins fold the next event healed it; now the only remedies are waiting for real time to catch up or another state_version bump.
Clears when: the fold (or emit) clamps ts to wall-clock-now plus a small tolerance, or a maintainer records that clock skew is accepted as out of scope.

Suggestions

  • If the clamp lands in RosterProjection.apply, the event envelope's own append time is a candidate ceiling — it keeps the rule inside the one place the monotone invariant already lives, with no new emit-side logic.

[DESIGN-REVIEWED] a164a95

Description read

[DESCRIPTION-READ] 58142b9727e087edb228e9d1d5793a7dc60f4a6898978400bb0381c49353024a

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 30, 2026
@github-actions

github-actions Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ✅ no blocking findings

GPT 5.6 completed its review of a164a9538cde0be17af96aa07bd2fbf2e76f5d8a and found no blocking issues.

This comment is updated in place on each push.

Review details

FINDING -- src/kiro_crew/dashboard/handlers/members.py:807 -- Function-local from kiro_crew.eventlog import types as eventlog_types violates top-level-imports -> Fix: move it to the module import block.
[GPT-REVIEWED] a164a95

False positive or not applicable? A repository writer can comment:
/ai-review override gpt a164a9538cde0be17af96aa07bd2fbf2e76f5d8a: <one-sentence reason>

@github-actions

github-actions Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — ✅ PASS

Premise-level review of a164a9538cde0be17af96aa07bd2fbf2e76f5d8a — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: PASS

Verify event-log growth: _on_row now appends a fsync'd member/message for every live row — machinery rows included — into an append-only log the PR itself calls "no compaction".

What this change ships

Inventory (8 items) — 6 justified, 2 harm-free riders

Intent: FIX — sorted by Recent, the crewmate the user just messaged now moves to the top of the roster, live; reproduced in the description and pinned by tests this PR adds that fail on base.

  1. The user's own send (and assistant rows behind a stream reader) now records recency — justified
  2. Recent ordering now reads the crew log's folded recency, floored by the transcript — justified
  3. A preview correction can no longer walk recency backwards; every existing roster savepoint is retired once (state_version 1→2, one-time cold re-fold) — justified
  4. A pushed frame can now advance a row's recency in the client (greater-of merge, replacing fill-if-empty — the reversed pin is quoted and rebutted in the description) — justified
  5. The open crewmate's row lifts to the top on its own advance; other rows hold position — justified
  6. The lifted row animates its travel (framer layout, off under reduced motion) — rides along; the fix is complete without it, but it names its harm (re-finding a teleported row) and uses the file's existing motion/reduceMotion idiom
  7. Committed recording script + recency capture-frame kind — rides along; conventional (10 sibling website/scripts/record-*.mjs scripts counted)
  8. member-event-log.md spec updated in the same commit — justified (AGENTS.md mandate)

[FIRST-PRINCIPLES-REVIEWED] a164a95

Description read

[DESCRIPTION-READ] e5567b7c2cedd1809be769e864fe1b0bf3a73c45e08320c992d84fabf2cc1e72

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Fable 5) — ✅ PASS

UX-level review of a164a9538cde0be17af96aa07bd2fbf2e76f5d8a — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

UX-Verdict: PASS

The GIF's first frame is blank white and the blind reader saw nothing in it — play shot-01.gif to confirm the row's travel was actually captured.

[UX-REVIEWED] a164a95

Description read

[DESCRIPTION-READ] 4dfe10ad4f59131d83a7b60a593f6d7adad07f06879500d2a8db81d280f96bae

That sha256 names everything this verdict read: the PR description, plus the 6 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Sep 30, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5 Review — ✅ no blocking findings

Reviewed a164a9538cde0be17af96aa07bd2fbf2e76f5d8a — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] a164a95

Verdict parsed from the review's SHA-scoped output markers for commit a164a9538cde0be17af96aa07bd2fbf2e76f5d8a.

False positive or not applicable? A repository writer can comment:
/ai-review override fable a164a9538cde0be17af96aa07bd2fbf2e76f5d8a: <one-sentence reason>

@chenmingwei23
chenmingwei23 force-pushed the fix/roster-recency-from-crewlog branch from 15e1bc8 to 69ff7f0 Compare September 30, 2026 05:46
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 30, 2026
@chenmingwei23
chenmingwei23 force-pushed the fix/roster-recency-from-crewlog branch 2 times, most recently from e226190 to 276fa48 Compare September 30, 2026 06:40
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 30, 2026
@chenmingwei23
chenmingwei23 force-pushed the fix/roster-recency-from-crewlog branch from 276fa48 to 32157b8 Compare September 30, 2026 08:13
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 30, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Backend Tests (Windows) (2) on this head is inherited from main, not from this change. It is tracked as #15361 (also #15364): three test/test_session_control_revive.py tests fail deterministically on the Windows shard on every PR rebased past #13110.

Attribution for this PR specifically:

  • test/test_session_control_revive.py does not exist at this branch's merge base. The shard runs it from the merge ref, which carries current main.
  • The same shard fails the same tests right now on PRs that touch neither dashboard/state.py nor session control -- one of them changes a single docs file.
  • The failures reproduce on the shard's re-run (attempt 2), so this is a standing red rather than a flake.

Separately, Backend Tests (Windows) (8) was red on the first attempt (test_members_dm_thread.py::TestResumeGuards::test_concurrent_member_resume_does_not_duplicate_history) and is green on the re-run. That one was a flake: this head's only delta from the previous one is three frontend files and no Python, and the identical backend passed all eight Windows shards on each of the three earlier heads.

Nothing here needs a change on this branch. The shard clears once #15361 lands on main.

… user's own send

Sorted by Recent, typing into a crewmate's DM left its row where it was. Four
things held it still, and each alone was enough.

The `member/message` event the roster's `last_active_ts` folds from was emitted
at the tail of `_broadcast_chat_message`, which `Slot.append` calls only when a
row still needs rendering -- never for a `user` row the composer already drew,
nor on a slot with an HTTP stream reader. That gate answers whether anything
needs to render the row, which says nothing about whether the row happened, so
the one action the user expects to reorder the roster recorded nothing. The emit
moves to `_record_member_row`, wired as a separate `Slot._on_row` hook that fires
for every live appended row; a replay (`broadcast=False`) still records nothing.

`GET /api/members` took the row's recency from the transcript's last SPEECH row,
which answers when the member last SAID something rather than when it was last
active. `_recency_for_row` now reads the response's own folded `roster`
projection, floored by the transcript so a dropped best-effort append and a
member with no log lose nothing.

`RosterProjection.last_active_ts` becomes monotone. `reconcile_member_preview`
appends its correction carrying the TRANSCRIPT's epoch, so a last-wins fold reset
recency to the last thing said on every roster read.

On the client, `last_active_ts` merges as the greater of row and pushed frame --
taking the row's value froze live frames out -- and `orderedMembers` re-sorts
when the OPEN crewmate's recency advances. The order hold still stands for a
background refetch, which is what must not move rows under the cursor.

Closes #15276
@chenmingwei23
chenmingwei23 force-pushed the fix/roster-recency-from-crewlog branch from 32157b8 to a164a95 Compare September 30, 2026 13:29
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 30, 2026
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 30, 2026

@iamwhatever iamwhatever left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Reviewed. No new handler; _recency_for_row reads the block already fetched for the row inside GET /api/members, MEMBER_MESSAGE shape unchanged so older readers are fine, v1->v2 fold bump costs one cold re-fold. The open-row lift only runs under the Recent sort after an advance, so it does not reorder the list. User rows pass through the same redaction chain.

Non-blocking: members_projections.py:139 makes one bad ts permanent; _parse_ts accepts True (1.0) and inf, and a future-dated ts from clock skew pins the fold. Rejecting bool/non-finite and clamping to now+epsilon would close it; no fold test for inf or a future ts.

@iamwhatever
iamwhatever enabled auto-merge (squash) September 30, 2026 17:37
@iamwhatever
iamwhatever merged commit 4ebdf05 into main Sep 30, 2026
181 of 190 checks passed
@iamwhatever
iamwhatever deleted the fix/roster-recency-from-crewlog branch September 30, 2026 17:38
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Sep 30, 2026
buluoray pushed a commit that referenced this pull request Sep 30, 2026
`eventlog.service.get_service()` memoises one `MemberEventLogService` per
process and rebuilds it only when the crew-log root moves. The root follows
`KIROCREW_HOME`, which the autouse `_isolate_kirocrew_home` fixture repoints at
a fresh tmp dir per test. A test that touches the service therefore leaves a
live singleton bound to its own home, and the next test on the same xdist
worker inherits it after that home is torn down.

On POSIX the next `get_service()` rebuilds against the new home and nothing is
observed. On Windows the leaked `MemberLog` still holds open OS handles under
the dead directory, which blocks the tmp-dir teardown and makes the inheriting
test's first write fail: `members.record_activity` catches the OSError and
returns False. That is the Windows-only red on
`TestMemberActivityRoute::test_the_read_never_asks_the_log_for_every_event`
and `::test_colliding_slugs_do_not_mix_histories` -- the first `record_activity`
line of each, which asserts a True return.

`fix(members): order the Recent roster by the crew log (#15277)` added
`test/test_members_roster_recency.py`, whose `TestRosterReadTakesTheFoldedRecency`
tests call `get_service()`/`ensure`/`append` without the module's
`set_service(None)` reset. That shifted the pytest-split shard-8 ordering so the
leaked service lands just before `TestMemberActivityRoute` on the same Windows
worker, surfacing a latent isolation hole that seven other test files share.

Fix: an autouse `_reset_member_eventlog_singleton` conftest fixture that clears
the singleton at both ends of every test, matching the existing
`_restore_autonudge_singleton` / reasoning-effort floors. A two-test pin in
`TestEventlogSingletonDoesNotLeakAcrossTests` locks the cause (a singleton
crossing the boundary) on both platforms; it fails without the fixture and
passes with it.

Co-authored-by: kirocrew-agent <agent@kirocrew.local>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

ux(members): the Recent sort does not move a crewmate up when the user messages it

2 participants