Skip to content

perf(coderd): write the chats row once per chat transition - #30267

Closed
cstyan wants to merge 7 commits into
mainfrom
callum/chatd-04-single-write
Closed

cstyan wants to merge 7 commits into
mainfrom
callum/chatd-04-single-write

Conversation

@cstyan

@cstyan cstyan commented Oct 1, 2026 •

Copy link
Copy Markdown
Collaborator

Discussing some potential changes to this with @hugodutka on slack, will update description to match reality once a path forward is decided.

Extended AI description

Postgres re-runs every foreign key check on an UPDATE whose old row version was written by the current transaction, and each check takes FOR KEY SHARE on the parent row. A chat transition used to bump snapshot_version at lock time and then update the chats row again from the message-history trigger, UpdateChatExecutionState, the attempt increment, the retry-state write, and one queue-version trigger per queued row, so every follow-up write re-checked owner_id, organization_id, and last_model_config_id on parent rows shared by every chat; pg_buffercache showed every backend queued on the users, organizations, and chat_model_configs heap pages.

Each transition now ends with exactly one chats UPDATE that also advances snapshot_version (UpdateChatExecutionState, IncrementChatGenerationAttempt, UpdateChatRetryState, or the new BumpChatSnapshotVersion, which Update issues itself when the callback made no commit write). LockChatForTransition replaces LockChatAndBumpSnapshotVersion and writes nothing; it also locks FOR NO KEY UPDATE, so foreign-key child writes such as the batched heartbeat upserts (FOR KEY SHARE) stop convoying against transitions. Migration 000614 drops the history and queue-version triggers; the commit write records those changes from flags set by the message and queue helpers, and the revision trigger stamps snapshot_version + 1. The lock's returned row, plus a queue count taken right after it, seeds the transaction so callbacks validate without re-reading the chat under the lock (tx.Current()), replacing the pre-reads in the HTTP handlers, task starters, and worker.

Why FOR NO KEY UPDATE: chats is the parent row of chat_heartbeats, chat_messages, chat_queued_messages, and child chats, so inserting or updating those takes FOR KEY SHARE on the chat row for the foreign key check. FOR UPDATE conflicts with FOR KEY SHARE, so heartbeat upserts waited behind every in-flight transition. FOR NO KEY UPDATE does not conflict with FOR KEY SHARE but still conflicts with itself, FOR UPDATE, and FOR SHARE, so transitions still serialize. It is safe because no transition changes chats.id. GetChatByIDForUpdate, LockChatByID, and the context-resource sync switch too so they keep the same mutual exclusion with Update.

Behavior changes for callers:

  • snapshot_version advances once per commit write, not once per Update, so a composite with two commit writes advances it by two.
  • A callback whose only write relies on Update's bump-only commit (for example a bare CommitStep) and reads the chat inside the callback sees the pre-commit versions. applySessionStartResponse, commitGenerationStep, and finishGenerationTurn's continue path do this; perf(coderd): publish and return the chat row from the transition's commit write #30268 replaces those reads with the commit write's result.
  • Triggers no longer record history or queue changes, so message and queue writes must go through the chatstate helpers that set the commit write's flags, not the raw store.
  • A callback that stages history or queue changes after a commit write (for example Acquire then CommitStep) now fails with ErrStagedAfterCommitWrite and rolls back. Recording those changes would need a second chats UPDATE, which brings back the foreign key re-checks this PR removes; before this check the changes were silently left unrecorded (history_version and generation_attempt stayed put while the message carried a revision the chat never reached). No production callback does this.

Why the queue is counted in its own statement: an earlier revision returned has_queued from an EXISTS subquery in LockChatForTransition to save a round trip. When that statement waits for the row lock, Postgres re-reads only the locked chat row; the subquery keeps the snapshot from before the wait. A queue change committed by the transition we waited behind was then invisible, so for example FinishTurn classified R1 as R0 and parked the chat in waiting with a non-empty queue. Main's TestQueuePromotionGuard_Concurrency caught this. A separate CountChatQueuedMessages after the lock sees everything committed before the lock was granted, and its correctness does not depend on how other code writes the queue.

Staged writes and commit writes: the helpers that write chat_messages or chat_queued_messages without touching the chats row are named stage* and live in chatstate/staged.go (the automation promotion guard's are in automation.go); commitExecutionState and the flag bookkeeping live in chatstate/commit.go. TestTransitionMatrix_AfterCommitWrite reruns every matrix case as if another transition had already committed, so any transition, including a future one, that stages without committing itself is rejected there (today CommitStep, DeleteQueuedMessage, and PromoteQueuedMessage when the guard drops a stale automation row). A new chatd callback that composes transitions in the wrong order is caught by any test that runs it; writes that bypass the stage* helpers are not caught.

Round trips under the row lock for a single-transition Update: main issues 7; this PR issues 5 (lock, queue count, commit write, and the publication's chat read and queue count). #30268 returns the row and queue state from the commit write, dropping the publication reads for 3 in total. A runnable result adds the heartbeat staleness check in each case.

Where a transition still writes the chats row more than once: SendMessage issues raw metadata UPDATEs in the same transaction when the request changes plan mode (UpdateChatPlanModeByID) or MCP servers (UpdateChatMCPServerIDs), and on a chat's first user turn (fallback UpdateChatTitleByID, written after the commit write). A send to an unowned running chat with interrupt runs two commit writes (sendMessageQueueAndSetStatus, then FinishInterruption). These are left as they are: they run once per user action, not per generation step or heartbeat, so they were not part of the contention this fixes. Folding them in would mean carrying plan mode, MCP server IDs, and the title through the commit write.

Database impact: in a pgbench emulation of the generated statements (48 clients, same host) LWLock:BufferContent fell from ~30% to ~15% of backend samples, insert and execution-state latencies dropped by about a quarter, and organizations left the hot page list. Scaletest data had transitions holding the row lock for 20-38 ms across 7-10 round trips; this removes the pre-callback chat re-read, and #30268 removes the post-callback reads.

Migration note: 000614 only drops triggers and replaces a trigger function, so it is quick. Replicas still on the previous version keep working against the new schema, but their message and queue writes no longer advance history_version/queue_version (those triggers are gone), so keep the mixed-version window of a rolling deploy short.

Main drift worth a look: UpdateChatExecutionState keeps #30241's retry_state clearing on leaving running (grant_history_epoch is folded into history_changed), and #30243's finishUnownedInterruption nests a full FinishInterruption inside Interrupt, so that composite is two commit writes; the transition matrix test now owns running chats in a seeder instead of inside the measured Update. The automation promotion guard's dropUnpromotable deletes queued rows, so it now sets the queue-changed flag (the queue-version trigger used to record those deletes).

Combined with the other PRs: #30268, #30269, and #30270 are based on this branch; if #30265 has merged first, the rewritten Update body keeps its phase-timing boundaries around LockChatForTransition.

Series: #30264 harness jitter, #30265 transition metrics, #30266 lock-free stream reads, #30267 single-write transitions, #30268 commit-write result and RBAC cache, #30269 non-blocking acquisition, #30270 finish turn in the step commit.


Generated by Coder Agents on behalf of @cstyan.

cstyan added 3 commits October 6, 2026 17:10
Postgres re-runs every foreign key check on an UPDATE whose old row version
was written by the current transaction. A transition used to bump
snapshot_version first and then update the chats row again from the message
history trigger, UpdateChatExecutionState, the attempt increment, the retry
state write, and one queue-version trigger per queued row. Each follow-up
write re-checked owner_id, organization_id, and last_model_config_id with
FOR KEY SHARE on parent rows shared by every chat, so all transitions
serialized on the users, organizations, and chat_model_configs heap pages
(pg_buffercache showed every backend queued on those three pages).

Each transition now ends with exactly one chats UPDATE that also advances
snapshot_version: UpdateChatExecutionState, IncrementChatGenerationAttempt,
UpdateChatRetryState, or the new BumpChatSnapshotVersion, which Update also
issues when a callback performed no commit write. LockChatForTransition
replaces LockChatAndBumpSnapshotVersion and writes nothing. The revision
trigger stamps snapshot_version + 1 (the version the transaction commits);
the history and queue-version triggers are dropped and the commit write
records those changes from flags set by the message and queue helpers.
InsertChat starts a chat at version 0 so CreateChat still lands on 1/1.
UpdateChatExecutionState keeps clearing retry_state whenever the chat
leaves running.

The lock also changes from FOR UPDATE to FOR NO KEY UPDATE (as do
GetChatByIDForUpdate, LockChatByID, and the context-resource sync):
transitions never change chats.id, and FOR UPDATE conflicted with the FOR
KEY SHARE locks that foreign-key child writes such as the batched
heartbeat upserts take on the chat row, so heartbeats and transitions
convoyed against each other.

The lock's RETURNING row, extended with has_queued, seeds the Tx. The first
loadState in a transaction returns it with no round trip. This is not a
cache across writes: every transition validates before it writes, so that
first call always precedes any execution-state mutation and sees exactly
the locked row. Later loadState calls read from the database, so bundles
of transitions still validate against the latest state. Tx.Current lets a
callback inspect state without consuming the seed; the HTTP handlers, the
task starters, and the worker's acquisition and abandon paths use it
instead of re-reading the chat under the lock. Publication keeps reading
the committed row after the commit write.

Regression tests pin the single-write contract and the round-trip budget:
a transition validates from the seed and updates the chats row exactly
once, a metadata-only callback still advances snapshot_version once, and a
bundle re-reads exactly once after the seed is consumed.

Emulation (48 clients, same host, pgbench with the generated statements):
LWLock:BufferContent fell from ~30% to ~15% of backend samples, insert and
exec-state latencies dropped by a quarter, and organizations left the hot
page list. Remaining shared-page work is the per-message model config FK
check and index maintenance on the commit write.
Remove the unused ChatMachine.Lock, rename the transition lock's cached row, and rewrite comments that described what instead of why. Document that snapshot_version now advances once per commit write and that FOR SHARE still blocks the transition lock.
…on callers

These six queries lost their last production callers in the chatd state machine refactor and write chat_messages or chat_queued_messages without setting the commit write's history and queue flags. Tests that seeded queue rows now use InsertChatQueuedMessageWithCreator.
@cstyan
cstyan force-pushed the callum/chatd-04-single-write branch from 2ccb0e5 to d304912 Compare October 6, 2026 17:36
@cstyan
cstyan marked this pull request as ready for review October 6, 2026 17:41
After a lock wait, Postgres re-reads only the locked chat row, so has_queued computed in the lock statement could miss queue changes committed during the wait. Count the queue in its own statement after the lock instead.
@cstyan

cstyan commented Oct 6, 2026

Copy link
Copy Markdown
Collaborator Author

@codex review

@chatgpt-codex-connector

Copy link
Copy Markdown

To use Codex here, create a Codex account and connect to github.

@cstyan

cstyan commented Oct 6, 2026

Copy link
Copy Markdown
Collaborator Author

/coder-agents-review

@coder-agents-review

coder-agents-review Bot commented Oct 6, 2026 •

Copy link
Copy Markdown
Contributor

Chat: Review posted | View chat
Requested: 2026-10-06 18:49 UTC by @cstyan

Review history
  • R1 (2026-10-06), 1 Nit, 7 P3, 1 P4, COMMENT. Review

deep-review v0.13.0 | Round 1 | 05eac08..7aa2856

Last posted: Round 1, 9 findings (7 P3, 1 P4, 1 Nit), COMMENT. Review

Finding inventory

Findings

# Sev Status Location Summary Round Reviewer Posted
CRF-1 P3 Open machine.go:297 Bump-only commit write skipped when commits > 0, so flags set after an earlier commit write are dropped R1 Netero Yes
CRF-2 P3 Open family.go:119 SetFamilyArchived uses loadState, adding reads under the lock and returning a pre-commit row for unchanged members R1 Netero Yes
CRF-3 P3 Open ARCHITECTURE.md:329 TODOs cite migration 000608 instead of 000614 (also line 394) R1 Netero Yes
CRF-4 P3 Open ARCHITECTURE.md:111 Architecture paragraphs made false by the PR get untracked TODOs instead of rewrites R1 Netero Yes
CRF-5 P3 Open chats.sql:2768 No test pins that FOR NO KEY UPDATE lets FK child writes through while transitions still serialize R1 Netero, Law Yes
CRF-6 P3 Open automation.go:165 No test covers queueChanged in dropUnpromotable; removing it passes the suite R1 Netero Yes
CRF-7 P3 Open transitions_test.go:41 Assertion message says history_version is set by the dropped trigger R1 Netero Yes
CRF-8 P4 Open tasks.go:516 ErrChatNotFound branch after tx.Current() is unreachable (also in loadLockedChatForTask, acquireCandidate, abandonAcquiredChat) R1 Netero Yes
CRF-9 Nit Open concurrency_test.go:70 121-character comment line in a file wrapped at about 72 R1 Netero Yes
CRF-10 OOS Out of scope (body) hook_server.go:85 handleAPIDispatchError still pre-reads the chat under the lock (unchanged code) R1 Netero No
CRF-11 OOS Out of scope (body) generation.go:427 syncMemoryIndex still pre-reads via loadChatForGeneration under the lock (unchanged line) R1 Netero No
CRF-12 OOS Out of scope (body) family.go:78 SetFamilyArchived locks each member twice (GetChatByIDForUpdate then LockChatForTransition) R1 Netero No

Contested and acknowledged

None.

Law analysis

Round 1. Head 7aa2856. Effective additions 1135. Verdict: Split. Enforcement: Mandatory.
Slices in landing order: C4 dead-query removal, C2 FOR NO KEY UPDATE lock strength, C1 single commit write (migration 000614 plus flags), C3 lock-seeded validation (tx.Current, queue count after lock). Mandatory call rests on C2 being independent of C1 with no test pinning the new lock conflicts.

Round log

Round 1

Netero plus Law. Law returned a mandatory split, so the panel was skipped. 7 P3, 1 P4, 1 Nit, 3 out of scope. Orchestrator moved hook_server.go:85 and generation.go:427 to out of scope (unchanged code, other instances of the pattern). Reviewed against 05eac08..7aa2856.

About deep-review

CRF = Coder Review Finding (P0-P4, Nit, Note)

Reviewer Focus
Bisky tests
Chopper ops/errors
Churn-guard change verification
Ging language modernization
Gon naming
Hisoka edge cases
Killua perf
Kite change integrity
Knov contracts
Knuckle SQL
Komugi flake/determinism
Kurapika security
Law decomposition
Leorio docs
Luffy product
Mafu-san process
Mafuuu contracts
Melody dispatch/pairing
Meruem structural
Nami frontend
Netero mechanical checks
Pariston premise testing
Pen-botter product gaps
Razor verification
Robin duplication
Ryosuke Go arch
Takumi concurrency
Zoro shape

🤖 Managed by Coder Agents.

@coder-agents-review coder-agents-review Bot 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.

This PR moves every chats-row write in a transition into one commit write, drops the history and queue-version triggers, weakens the chat row locks to FOR NO KEY UPDATE, and seeds callbacks from the locked row. This round is a first pass only: mechanical findings plus a split assessment. The full review panel has not reviewed the PR yet and will review once the split lands. Findings: 7 P3, 1 P4, 1 Nit.

Split required. The PR carries four changes that can land and be reviewed separately, in this order:

  1. Remove the six queue and message queries with no production callers and ChatMachine.Lock (commit d304912 and the related deletions). No behavior change.
  2. Change the chat row locks (GetChatByIDForUpdate, LockChatByID, the context-resource sync CTE, and the transition lock) to FOR NO KEY UPDATE, with a test showing a heartbeat upsert completes while a transition holds the lock and a second transition still blocks. On main, LockChatAndBumpSnapshotVersion takes FOR UPDATE in its subquery, so this change works there without the rest of the PR.
  3. Single commit write: migration 000614, the commit-write queries, the history and queue flags in transitions.go, machine.go, and automation.go.
  4. Validate from the locked row: lockedRow, Tx.Current, the queue count after the lock, and the pre-read removals in chatd.go, tasks.go, generation.go, and worker.go.
    The lock change is the required split: it changes which writers exclude each other on chats, no test pins either the new non-blocking behavior or the exclusions that must remain, and inside this diff it is four keywords. Splitting 1 and 4 out is recommended. A layer split of item 3 does not work, because dropping the triggers without the flag code leaves history_version and queue_version stale.

Out of scope (needs a ticket or explicit acceptance by a human):

  • coderd/x/chatd/hook_server.go:85: handleAPIDispatchError still reads the chat with store.GetChatByID inside machine.Update, adding a round trip under the row lock.
  • coderd/x/chatd/generation.go:427: syncMemoryIndex still calls loadChatForGeneration(ctx, store, ...) inside machine.Update, adding a read under the lock on every turn that commits a memory index message.
  • coderd/x/chatd/chatstate/family.go:78: SetFamilyArchived locks each member with GetChatByIDForUpdate and again with LockChatForTransition, so every member pays two lock statements.

coderd/x/chatd/chatstate/family.go:119

P3 [CRF-2] SetFamilyArchived calls state.loadState(), which now consumes the locked row. (Netero)

Each member that needs archiving then pays an extra GetChatByID and CountChatQueuedMessages under the lock (a scratch test counted 3 and 3, against 2 and 2 with Current()). A member already at the requested value returns current, and Update's bump-only write runs after the callback, so the caller gets SnapshotVersion=3 while the database holds 4. Use state.Current() here, as the other callbacks in this PR do.

🤖

coderd/x/chatd/chatstate/transitions_test.go:41

P3 [CRF-7] The assertion message "history_version set by trigger after initial insert" is false after this PR. (Netero)

The creation commit write (BumpChatSnapshotVersion with HistoryChanged: true) sets it, and migration 000614 drops the trigger. Change the message to say so.

🤖

🤖 This review was automatically generated with Coder Agents.

return err
}
chat, state, err := tx.loadState()
if tx.commits == 0 {

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.

P3 [CRF-1] Update issues the bump-only commit write only when tx.commits == 0, so a history or queue flag set after an earlier commit write in the same callback is dropped. (Netero)

A scratch test running Acquire and then CommitStep in one Update ended at snapshot_version=2, history_version=1, with the inserted message at revision=3, so the generation history fence does not move and no error is reported. No production callback runs a flag-only transition after a commit write today. Bump when tx.commits == 0 || tx.historyChanged || tx.queueChanged, or return an error for pending flags as requireNoVersionFlags does.

🤖

Comment thread coderd/x/chatd/ARCHITECTURE.md Outdated

`chats.history_version` stores the latest `snapshot_version` in which chat message history changed. It starts at `0`, remains unchanged for non-history transitions, and is set to the current `snapshot_version` whenever a message is inserted or meaningfully updated. A newly created chat starts with `snapshot_version = 1`; because `Create` inserts initial history in that snapshot, the created chat's `history_version` becomes `1`. No-op message updates do not advance message `revision`, advance `history_version`, or reset `generation_attempt`. Whenever `history_version` changes, `generation_attempt` is reset to `0`; generation attempts are scoped to the current history version.

TODO: the invariant is now the reverse: the `BEFORE INSERT`/`BEFORE UPDATE` trigger stamps `revision = snapshot_version + 1`, the version the enclosing transaction commits, and every transaction that writes `chat_messages` must end with a commit write that advances `snapshot_version` and sets `history_version` (the `AFTER` triggers that wrote `history_version` and reset `generation_attempt` were dropped in migration 000608). Rewrite this paragraph and the trigger listing below accordingly.

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.

P3 [CRF-3] This TODO says the triggers were dropped in migration 000608, but this PR drops them in 000614_chat_single_transition_write; 000608 is 000608_chat_title_source. (Netero)

The same number is wrong at line 394. Change both to 000614.

🤖


We will not define the SQL queries that correspond to each transition - it'd take too much space and it's not central to the document's purpose. Instead, we focus on what each transition does to the database state, and how it affects the execution and ownership states.

TODO: the transition lock no longer writes the row. Each transition ends with a single commit write (`UpdateChatExecutionState`, `BumpChatSnapshotVersion`, `IncrementChatGenerationAttempt`, or `UpdateChatRetryState`) that advances `snapshot_version` together with the transition's own fields, and `ChatMachine.Update` issues a bump-only commit write when the callback performed none. Rewrite this paragraph and the two that follow: `history_version` and `queue_version` are now written by the commit write (from write-intent flags set by the message and queue helpers), not by triggers. The motivation is that Postgres re-runs every FK check on an UPDATE whose old row version was written by the same transaction, and those checks key-share the parent rows shared by all chats (users, organizations, chat_model_configs).

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.

P3 [CRF-4] The PR adds five TODO notes next to architecture paragraphs it makes false, instead of rewriting them. (Netero)

Line 113 still says snapshot_version advances immediately after locking and before mutating any tables, and lines 117 to 119 and the trigger listing from line 396 still describe trigger-maintained history_version and queue_version. Root AGENTS.md requires updating the architecture document when chatd architecture changes, and these TODOs link no ticket. Rewrite the affected paragraphs in this PR.

🤖

SELECT *
FROM chats
WHERE id = @id::uuid
FOR NO KEY UPDATE

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.

P3 [CRF-5] No test checks that the transition lock lets FOR KEY SHARE child writes, such as heartbeat upserts, through. (Netero, Law)

rg 'NO KEY|KEY SHARE' -g '*_test.go' returns nothing, and TestConcurrentUpdatesSerializeOnChatRow only covers transitions serializing against each other, so reverting this lock to FOR UPDATE passes every test and brings back the heartbeat convoy. Add a test that holds an Update callback open and requires a heartbeat upsert for the same chat to finish before the callback is released.

🤖

if count != 1 {
return nil, xerrors.Errorf("delete unpromotable queued message %d: deleted %d rows, want 1", row.ID, count)
}
tx.queueChanged = true

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.

P3 [CRF-6] No test covers tx.queueChanged = true in dropUnpromotable. (Netero)

With this line removed, go test ./coderd/x/chatd/chatstate/ -count=1 still passes. When the guard drops every queued row, this flag is the only thing that advances queue_version, so without it stream consumers keyed on queue_version would not refetch (inferred, not run). Assert that QueueVersion advances in the existing guard-drop tests.

🤖

Comment thread coderd/x/chatd/tasks.go
err := machine.Update(ctx, func(tx *chatstate.Tx, _ database.Store) error {
// Row already locked by ChatMachine.Update (LockChatForTransition).
chat, _, err := tx.Current()
if err != nil {

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.

P4 [CRF-8] The ErrChatNotFound branch after tx.Current() cannot run, so mismatch = true never fires for a deleted chat. (Netero)

On the first call Current() returns the row LockChatForTransition returned with a nil error, and a missing chat makes Update return ErrChatNotFound before the callback runs. The same unreachable branch is in loadLockedChatForTask, acquireCandidate, and abandonAcquiredChat. Delete these branches, or handle the deleted chat at the Update call site.

🤖

// TestReadSnapshotNotBlockedByRowLock verifies that a ReadSnapshot
// completes while another transaction holds the chat row's FOR UPDATE
// lock. The former FOR SHARE read would have queued behind it.
// completes while an Update holds the chat row's transition lock. The former FOR SHARE read would have queued behind it.

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.

Nit [CRF-9] This doc comment line is 121 characters, while the rest of the file wraps comments at about 72. (Netero)

Wrap it to match.

🤖

cstyan added 3 commits October 6, 2026 22:01
… after the commit write

Update skipped its bump once a transition had committed, silently dropping later staged changes. It now returns ErrStagedAfterCommitWrite, and every matrix transition is tested in the after-commit position.
…commit writes

Helpers that write messages or queue rows without a commit write are now stage* and live in staged.go; the commit write helpers live in commit.go as commitExecutionState. No behavior change.
SetFamilyArchived classifies members with Current so SetArchived
validates against the locked row instead of re-reading the chat and
recounting the queue. Remove not-found branches that cannot follow
tx.Current, pin the FOR NO KEY UPDATE lock mode with a heartbeat insert
test, assert that guard drops advance queue_version, and update the
comments, test names, and database comments that still described the
dropped version triggers. Point the architecture doc TODOs at migration
000614.
@linear-code

linear-code Bot commented Oct 29, 2026

Copy link
Copy Markdown

GRU-110

@cstyan cstyan closed this Nov 9, 2026
@cstyan
cstyan temporarily deployed to main November 9, 2026 22:15 — with GitHub Actions Inactive
@github-actions github-actions Bot locked and limited conversation to collaborators Nov 9, 2026

This branch was previously deployed

1 inactive deployment
main — 0df197b8 Deployed Nov 9, 2026 by cstyan via cla #252909
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant