Skip to content

perf(coderd): publish and return the chat row from the transition's commit write - #30268

Closed
cstyan wants to merge 1 commit into
callum/chatd-04-single-writefrom
callum/chatd-05-commit-write-result
Closed

cstyan wants to merge 1 commit into
callum/chatd-04-single-writefrom
callum/chatd-05-commit-write-result

Conversation

@cstyan

@cstyan cstyan commented Oct 1, 2026 •

Copy link
Copy Markdown
Collaborator

Two round-trip sources remained under the transition lock after #30267: every hot chat write in dbauthz (UpdateChatExecutionState, InsertChatMessages, IncrementChatGenerationAttempt, UpdateChatRetryState, the queue and heartbeat reads) pre-read the chat through the chats_expanded join to authorize, and Update re-read the chat, queue count, and heartbeat after the callback to publish. Following the workspace RBAC-in-context pattern (#20662, #21047), the chat's RBAC object (ID, owner, org; never ACLs, which change at runtime) is cached on the context: Update caches it from the lock's own row, and the chat HTTP middleware and the worker runner cache it up front. Every commit write now returns the committed row plus has_queued and ownership_stale, so Update publishes from that result and UpdateReturning hands the same row to callers, replacing the post-write GetChatByID reloads in the handlers, task starters, and generation loop.

Database impact: through dbauthz a single transition now reads the chat once (the lock's pre-lock authorization) instead of once per write, and not at all when the caller cached the object; the three post-callback reads under the lock are gone. It also fixes two defects #30267 has on its own: the runner hint routed from commitGenerationStep and the session-start history fence both used a reload taken before Update's bump-only write.

Combined with the other PRs: based on #30267; with #30269 the acquisition pre-check feeds the cache (CacheableChatRBACFor, owner_id/organization_id on GetChatTransitionState) and UpdateReturning locks through lockChat, and with #30270 the finish branch in commitGenerationStep reduces to finished = true; whichever merges second makes those edits.

Depends on #30267.

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.

…ommit write

Every hot chat write in dbauthz (UpdateChatExecutionState,
InsertChatMessages, IncrementChatGenerationAttempt, UpdateChatRetryState,
and the queue/heartbeat reads) pre-read the chat with the full
chats_expanded join to authorize. Those reads run inside the transition
callback while the chat row lock is held, so they lengthened every hold
on top of the lock's own pre-lock pre-read.

Follow the workspace RBAC-in-context pattern (#20662, #21047): cache the
chat's RBAC object on the context and let chat-scoped dbauthz methods
authorize against it, falling back to the fetch on any failure. The
cached object carries only ID, owner, and org, which never change for a
chat, and must not carry ACLs since sharing changes at runtime; a cached
object for a different chat ID is ignored. ChatMachine.Update caches the
object from the lock's own row on the transaction context, so every
transition method's write authorizes without a read. The chat HTTP
middleware and the worker runner cache it up front so the lock's
authorization skips its read too.

Every commit write (UpdateChatExecutionState, BumpChatSnapshotVersion,
UpdateChatRetryState, IncrementChatGenerationAttempt) now returns the
committed chat row together with has_queued and ownership_stale, so
ChatMachine.Update publishes from that result instead of reading the
chat again under the lock, and UpdateReturning hands the same row to
callers. The commit write is the last statement of a transition that
can change the row, the queue, or the heartbeat, so the result is
exact; Acquire writes its heartbeat first so the lease it evaluates is
fresh.

Callers that reloaded the chat after a transition use the returned row
instead. For callbacks whose only write is CommitStep, the reload ran
before Update's bump-only write and returned the pre-bump versions, so
the runner hint routed from commitGenerationStep was always dropped and
applySessionStartResponse continued with a stale history fence.
SendMessage's first-turn fallback title is written after the commit
write, so that path returns the title write's row.

Through dbauthz, a single transition now reads the chat once (the lock's
pre-lock authorization) instead of once per write, and not at all when
the caller cached the object or the commit write returned the row.
@cstyan
cstyan force-pushed the callum/chatd-05-commit-write-result branch from 8a281a2 to e43ac74 Compare October 7, 2026 01:11
@cstyan

cstyan commented Oct 7, 2026

Copy link
Copy Markdown
Collaborator Author

/coder-agents-review

@coder-agents-review

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

Copy link
Copy Markdown
Contributor

Chat: Review posted | View chat
Requested: 2026-10-07 01:17 UTC by @cstyan

Review history
  • R1 (2026-10-07): 13 reviewers, 8 Nit, 2 P2, 9 P3, 9 P4, COMMENT. Review

deep-review v0.13.0 | Round 1 | 0df197b..e43ac74

Last posted: Round 1, 28 findings (2 P2, 9 P3, 9 P4, 8 Nit), COMMENT. Review

Finding inventory

Findings

# Sev Status Location Summary Round Reviewer Posted
CRF-1 P2 Open coderd/x/chatd/generation.go:430 syncMemoryIndex reload before bump-only write leaves stale HistoryVersion R1 Netero Yes
CRF-2 P3 Open coderd/x/chatd/hooks_internal_test.go:95 No regression tests for the two defects the PR claims to fix R1 Netero Yes
CRF-3 P3 Open coderd/database/dbauthz/dbauthz.go:190 authorizeChatByID fallback after cached denial untested R1 Netero, Mafuuu Yes
CRF-4 P3 Open coderd/database/queries/chats.sql:3333 IsChatHeartbeatStale comment names removed chatstate caller R1 Netero Yes
CRF-5 P4 Open coderd/database/queries/chats.sql:2946 has_queued/ownership_stale SQL block duplicated in four queries R1 Netero Yes
CRF-6 Nit Open coderd/x/chatd/chatd.go:2440 refreshed names now hold the commit row R1 Netero Yes
CRF-7 Note Note (body) coderd/x/chatd/ARCHITECTURE.md:727 Architecture change recorded as TODO R1 Netero No
CRF-8 P2 Open coderd/database/dbauthz/dbauthz_test.go:8256 No test proves the fast path authorizes; skipping authorization passes all tests R1 Bisky Yes
CRF-9 P3 Open coderd/database/dbauthz/dbauthz.go:185 Queue/message dbauthz methods ignore the cache; "reads the chat once" false for queued paths R1 Melody, Knov, Netero Yes
CRF-10 P3 Open coderd/x/chatd/chatstate/machine.go:345 UpdateReturning zero row on COMMIT error disables committedStateAfterUpdateError recovery R1 Melody, Ryosuke, Pariston Yes
CRF-11 P3 Open coderd/httpmw/chatparam.go:50 Middleware and runner cache sites not asserted by any test R1 Bisky Yes
CRF-12 P3 Open coderd/database/queries/chats.sql:2933 has_queued cannot change IsRunnable; dead column in four queries R1 Bisky Yes
CRF-13 P3 Open coderd/database/queries/chats.sql:2946 ownership_stale is true for unowned chats; name hides "or missing" R1 Gon Yes
CRF-14 P3 Open coderd/database/queries/chats.sql:2944 stale_seconds undocumented; zero marks every lease stale R1 Gon Yes
CRF-15 P4 Open coderd/x/chatd/chatstate/machine.go:325 Tx.commits and Tx.committed track one fact twice R1 Ryosuke, Bisky Yes
CRF-16 P4 Open coderd/x/chatd/chatstate/machine.go:291 WithChatRBAC error fails Update but is ignored at the other two sites R1 Ryosuke, Gon Yes
CRF-17 P4 Open coderd/database/dbauthz/chat_rbac_context.go:17 CacheableChatRBAC rebuilds Chat.RBACObject by hand; can drift R1 Ryosuke, Gon, Knov Yes
CRF-18 P4 Open coderd/x/chatd/chatstate/machine.go:239 UpdateReturning doc says committed; nested tx returns uncommitted row R1 Leorio, Ryosuke Yes
CRF-19 P4 Open coderd/x/chatd/chatstate/machine.go:242 Metadata writes after the commit write are absent from the returned row; undocumented R1 Knov Yes
CRF-20 P4 Open coderd/x/chatd/chatstate/roundtrips_test.go:360 newAuthzStore duplicates the setup in TestLockAutomations_AsChatd R1 Ging-Go Yes
CRF-21 P4 Open coderd/x/chatd/chatstate/roundtrips_test.go:371 Test doc names the bump; the remaining read is the lock's authorization R1 Gon Yes
CRF-22 P4 Open coderd/database/dbauthz/chat_rbac_context.go:32 WithChatRBAC doc says callers fall back; authorizeChatByID does R1 Gon Yes
CRF-23 Nit Open coderd/x/chatd/chatd.go:1683 Five call-site comments restate the UpdateReturning contract R1 Gon P2, Leorio Nit Yes
CRF-24 Nit Open coderd/x/chatd/chatstate/machine.go:198 Several new machine.go comments restate code or nearby docs R1 Gon P2 Yes
CRF-25 Nit Open coderd/httpmw/chatparam.go:48 Metaphor in cache comment R1 Gon P2 Yes
CRF-26 Nit Open coderd/database/queries/chats.sql:3138 IncrementChatGenerationAttempt doc dropped the LockChatForTransition pointer R1 Gon P2 Yes
CRF-27 Nit Open coderd/x/chatd/chatstate/roundtrips_test.go:399 Test name says ReadsNothing; it asserts only GetChatByID is zero R1 Gon P4 Yes
CRF-28 Nit Open coderd/x/chatd/chatstate/transitions.go:227 refreshed in insertChat holds the bump row R1 Gon Yes
CRF-29 Nit Open coderd/x/chatd/chatstate/machine.go:279 committed names both a Chat and *commitResult in updateOnce R1 Gon Yes
CRF-30 P2 Dropped by orchestrator (doc is accurate: the "stale grant" sentence describes the ACL omission; Leorio cites it as a good example) coderd/database/dbauthz/dbauthz.go:177 authorizeChatByID doc verbose R1 Gon No
CRF-31 Note Note (body) commit e43ac74 Commit message contradicts itself on reads and last-statement claim R1 Leorio No
CRF-32 Note Note (body) coderd/x/chatd/ARCHITECTURE.md:727 TODO claims chat row touched only by lock and commit write; title write follows R1 Pariston No
CRF-33 Note Note (body) coderd/database/queries/chats.sql:2930 Heartbeat-before-commit-write order is not enforced R1 Mafuuu No
CRF-34 Note Note (body) coderd/database/dbauthz/dbauthz.go:186 ACL-only users pay a failed fast-path evaluation per chat call R1 Killua, Mafuuu No
CRF-35 Note Note (body) coderd/database/dbauthz/chat_rbac_context.go:13 Fast path relies on owner/org immutability with no guard R1 Kurapika No
CRF-36 Note Dropped by orchestrator (PR mirrors workspace pattern intentionally; conditional on a third resource type) coderd/database/dbauthz/chat_rbac_context.go:24 chat_rbac_context copies workspace_rbac_context R1 Ging-Go No
CRF-37 OOS Out of scope (body) coderd/x/chatd/hook_server.go:85 handleAPIDispatchError reads the chat twice under the lock R1 Netero, Knuckle, Ryosuke, Mafuuu, Takumi No
CRF-38 OOS Out of scope (body) coderd/x/chatd/worker.go:276 acquireCandidate IsChatHeartbeatStale uses outer ctx; reads chat under lock R1 Takumi No
CRF-39 OOS Out of scope (body) coderd/x/chatd/chatstate/machine.go:16 HeartbeatStaleSeconds constant vs configurable opts.HeartbeatStaleSeconds R1 Gon No
CRF-40 OOS Out of scope (body) coderd/x/chatd/chatd.go:1564 Lock comments name Update in UpdateReturning callbacks R1 Gon No

Contested and acknowledged

Law analysis

Not run. Effective additions 687 (threshold 1000).

Round log

Round 1

Full panel (round 1). Netero first pass: 1 P2, 3 P3, 1 P4, 1 Nit, 1 Note, no P0, panel proceeded. Panel: ging-go, killua, knuckle, kurapika, melody, ryosuke, takumi (specialists), pariston, mafuuu (core), bisky, gon, leorio (pool, Bisky required, Gon/Leorio floor), knov (wildcard). Panel size 13 exceeds the 9-12 target because seven specialists (ging-go, killua, knuckle, kurapika, melody, ryosuke, takumi) are triggered. Gon's comment-style P2s downgraded to Nit (convention-only, no behavior consequence). Totals posted: 2 P2, 9 P3, 9 P4, 8 Nit. Reviewed against 0df197b..e43ac74.

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 caches the chat RBAC object on the context so dbauthz skips the chat pre-read, and makes the four commit writes return the committed row with has_queued and ownership_stale so Update publishes without re-reading. 2 P2, 9 P3, 9 P4, 8 Nit.

The commit message for e43ac74 contradicts itself in two places: it says a transition reads the chat "once (the lock's pre-lock authorization)" and then "not at all when ... the commit write returned the row", and it calls the commit write the last statement "that can change the row" while the next paragraph says SendMessage writes the title after it. Delete "or the commit write returned the row" and name the queue, the heartbeat, and the fields chat:update carries instead of "the row".

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

  • coderd/x/chatd/hook_server.go:85 and :100: handleAPIDispatchError reads the chat with GetChatByID before and after FinishError, two reads under the transition lock that the other handlers no longer pay.
  • coderd/x/chatd/worker.go:276 and :340: acquireCandidate calls IsChatHeartbeatStale with the outer ctx, which has no cached RBAC object, so dbauthz reads the chat under the row lock and under the capacity advisory lock.
  • coderd/x/chatd/chatstate/machine.go:16: commit writes use the constant HeartbeatStaleSeconds (30) while acquisition uses the configurable opts.HeartbeatStaleSeconds, so a deployment that changes the option gets ownership hints on a different threshold than acquisition.
  • coderd/x/chatd/chatd.go:1564: the "Row already locked by ChatMachine.Update" comments now sit in UpdateReturning callbacks.

Notes:

  • coderd/x/chatd/ARCHITECTURE.md:727: the change is recorded as a TODO, and the TODO says a transition touches the chat row only through its lock and its commit write, which the SendMessage title write after the commit write contradicts.
  • coderd/database/queries/chats.sql:2930: the claim that the commit write is the last statement touching the heartbeat is enforced only by statement order in Acquire; nothing fails if a later transition upserts the heartbeat after its commit write.
  • coderd/database/dbauthz/dbauthz.go:186: a user who reaches a chat only through a sharing ACL now pays a denied fast-path evaluation and a debug log line before the GetChatByID fallback on every chat call.
  • coderd/database/dbauthz/chat_rbac_context.go:13: the fast path is correct only while no query changes chats.owner_id or chats.organization_id; no test or check enforces that.

coderd/x/chatd/generation.go:430

P2 [CRF-1] syncMemoryIndex still reloads the chat inside the callback, before Update's bump-only write, so input.HistoryVersion gets the pre-bump value. (Netero)

CommitStep runs no commit write, so BumpChatSnapshotVersion advances history_version after this read. The next loadChatForTask with requireHistory: true then fails the fence (tasks.go:669) and returns errTaskExpectedExit, which I infer ends the generation task after every memory index commit until the runner dispatches a new one. Use machine.UpdateReturning and drop the reload, as the PR already does for applySessionStartResponse.

🤖

coderd/x/chatd/hooks_internal_test.go:95

P3 [CRF-2] The two defects the PR description says it fixes (the session-start history fence and the commitGenerationStep runner hint) have no regression test. (Netero)

TestApplySessionStartResponse asserts only the inserted messages and passes with the old pre-bump reload, and no changed test exercises commitGenerationStep. Assert that the returned chat's HistoryVersion and SnapshotVersion equal a fresh GetChatByID after applySessionStartResponse, and the same for the chat commitGenerationStep routes.

🤖

coderd/database/queries/chats.sql:3333

P3 [CRF-4] The IsChatHeartbeatStale comment says "chatstate calls this", but this PR removed chatstate's only caller (ownershipStaleOrMissing). (Netero)

The remaining callers are worker.go:277 and :343. Name the worker acquisition path instead.

🤖

coderd/x/chatd/chatstate/transitions.go:227

Nit [CRF-28] refreshed in insertChat now holds a BumpChatSnapshotVersionRow from the commit write, not a reload. (Gon)

Rename to bumped, as dbgen.go:151 does.

🤖

🤖 This review was automatically generated with Coder Agents.

if err := q.authorizeContext(ctx, action, rbacObj); err == nil {
return nil
}
q.log.Debug(ctx, "fast path authorization failed for chat, using slow path",

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] The fallback branch of authorizeChatByID, taken when the cached object is denied, has no test coverage. (Netero, Mafuuu)

This branch keeps ACL-shared users working now that ExtractChatParam caches an ACL-free object for every chat request; coverage shows dbauthz.go:190.3,191.30 at count 0. TestChatWriteAuthorization_FastPath uses AlwaysReturn(nil), so it cannot reach it. Add a subtest whose authorizer denies the cached object and allows the fetched one, and assert GetChatByID is called and the write succeeds.

🤖

AND h.runner_id = chats_expanded.runner_id
AND h.heartbeat_at > NOW() - (INTERVAL '1 second' * @stale_seconds::int)
)
)::boolean AS ownership_stale

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-5] The has_queued/ownership_stale select block is copied into four queries, and its heartbeat predicate is a fifth copy of IsChatHeartbeatStale. (Netero)

A change to the lease rule has to be made in five places, and a missed copy makes Update publish or suppress chat:ownership hints depending on which commit write ran. A SQL function such as chat_ownership_stale(chat_id, runner_id, worker_id, stale_seconds) called from all five sites keeps one definition.

🤖

Comment thread coderd/x/chatd/chatd.go
var result chatstate.InterruptResult
machine := p.newChatMachine(chat.ID)
err := machine.Update(ctx, func(tx *chatstate.Tx, store database.Store) error {
refreshed, err := machine.UpdateReturning(ctx, func(tx *chatstate.Tx, _ database.Store) error {

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-6] InterruptChat and ReconcileInvalidStateChat (line 2628) still call the result refreshed, but it is now the commit write's row. (Netero)

The other converted call sites use committed or committedChat.

🤖

})
}

func TestChatWriteAuthorization_FastPath(t *testing.T) {

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.

P2 [CRF-8] No test proves the authorizeChatByID fast path authorizes anything. (Bisky)

Reproduced: replacing q.authorizeContext(ctx, action, rbacObj) at dbauthz.go:187 with error(nil) leaves TestChatWriteAuthorization_FastPath, TestWithChatRBAC, TestMethodTestSuite/TestChats, and TestUpdateThroughDBAuthz* passing, because this test uses AlwaysReturn(nil) and the round-trip tests run as AsChatd. A regression that skips authorization for every caller with a cached object (HTTP middleware, runner, every Update) would ship with green tests. Add a subtest with a member who has no access to the chat, cache CacheableChatRBAC(chat), call UpdateChatExecutionState, and assert dbauthz.IsNotAuthorizedError(err); in the existing subtest, assert the recorded actor, object, and policy.ActionUpdate.

🤖

// ACL-dependent grant is never served from the cache.
//
// Slow path: fetch the chat and authorize against it.
func (q *querier) authorizeChatByID(ctx context.Context, chatID uuid.UUID, action policy.Action) error {

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-9] The queue and message dbauthz methods that transitions call on tx.ctx still read the chat before authorizing, so the description's "reads the chat once ... instead of once per write" is false for Acquire, queued sends, and FinishTurn with a queued head. (Melody, Knov, Netero)

Reproduced with a scratch test modeled on TestUpdateThroughDBAuthzWithCallerCachedRBACReadsNothing: a queued tx.SendMessage issued 1 GetChatByID, tx.FinishTurn with a queued head issued 3, and Acquire issued 1, against the 0 the existing test asserts for an empty-queue FinishTurn. The methods include UpsertChatHeartbeat, InsertChatQueuedMessageWithCreator, GetChatQueuedMessageHead, GetChatQueuedMessagesByPosition, DeleteChatQueuedMessageReturningCount, DeleteAllChatQueuedMessagesReturningCount, ReorderChatQueuedMessageToHead, GetChatQueuedMessageByID, SoftDeleteChatMessageByID, SoftDeleteChatMessagesAfterID, GetChatMessageByID, GetChatMessagesByChatID, and UpdateChatTitleByID. Route them through authorizeChatByID and extend the round-trip test to a queued FinishTurn, or narrow the database-impact claim to the transitions it covers.

🤖

// the transaction function succeeds. If the transaction rolls back,
// the deferred Discard suppresses every buffered publication so
// subscribers never see uncommitted state.
// versions. The commit write returns the committed row together with

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-24] The new clause about the commit write returning the flags repeats commitResult's doc (line 98); the same applies to the committed field comment (line 74), the recordCommit comment (line 106), and "The lock returned the authoritative row." (line 288). (Gon)

Keep Update's doc to what is published and when, delete the recordCommit comment, and start the line 288 comment with its reason.

🤖

}

ctx = context.WithValue(ctx, chatParamContextKey{}, chat)
// The request already paid for this read; cache the chat's RBAC

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-25] "The request already paid for this read" is a metaphor. (Gon)

Rewrite: "Lets dbauthz authorize this request's chat queries without reading the chat again."

🤖

updated_at = NOW()
WHERE id = @id::uuid
RETURNING generation_attempt;
-- The commit write of RecordGenerationAttempt: advances snapshot_version,

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-26] The rewritten IncrementChatGenerationAttempt doc repeats the SET list and drops the (see LockChatForTransition) pointer that UpdateChatRetryState keeps. (Gon)

Restore the pointer to the single-UPDATE rule.

🤖

// can cache its RBAC object up front so even the lock authorizes without a
// read: the transition then touches the chat row only through the lock and
// its commit write.
func TestUpdateThroughDBAuthzWithCallerCachedRBACReadsNothing(t *testing.T) {

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-27] TestUpdateThroughDBAuthzWithCallerCachedRBACReadsNothing asserts only that GetChatByID is zero; it still expects one LockChatForTransition. (Gon)

Rename to TestUpdateThroughDBAuthzWithCallerCachedRBACSkipsGetChatByID.

🤖

buffer := NewPublishBuffer(m.publisher)
defer buffer.Discard()

var committed database.Chat

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-29] updateOnce uses committed for a local database.Chat and reads tx.committed (a *commitResult) two lines before assigning one to the other. (Gon)

Rename the local to committedChat, the name chatd.go uses for the same value.

🤖

@linear-code

linear-code Bot commented Oct 29, 2026

Copy link
Copy Markdown

GRU-112

@cstyan cstyan closed this Nov 9, 2026
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.

1 participant