perf(opencode): reduce redundant summary and queue overhead

[GuestAUser]

Summary

• dedupe identical in-flight SessionSummary.summarize() calls so concurrent summary work shares one computation instead of re-reading messages and re-running snapshot diffs in parallel
• replace AsyncQueue's Array.shift() dequeue path with a head-index queue to remove O(n) copies from hot SSE / event / TUI delivery paths
• avoid rereading persisted tool parts during SessionProcessor cleanup by using the in-memory ctx.toolcalls map that already tracks active tool calls

Why

The current opencode hot path still pays for a few avoidable costs in high-frequency paths:

• summary generation can be triggered concurrently for the same {sessionID, messageID} pair, which duplicates message hydration and diff work
• queue consumers pay repeated shift() costs during sustained event delivery
• processor cleanup rereads message parts that are already available in memory

None of these change the user-visible model behavior. The goal here is to shave redundant work from core loop infrastructure while preserving fault tolerance and existing tool-loop semantics.

What changed

1. Single-flight session summary work

packages/opencode/src/session/summary.ts

• adds per-instance summary state through InstanceState
• uses Effect Cache.make() to share one in-flight summarize operation per [sessionID, messageID]
• invalidates the cache entry after completion so this remains single-flight work sharing rather than long-lived result caching
• keeps the rest of the summary pipeline unchanged: session summary aggregation, stored diff write, diff event publish, and user-message summary update

packages/opencode/test/session/summary.test.ts

• adds a regression test that fires two concurrent summarize calls
• verifies only one message load and one diff computation happen

2. O(1) queue dequeue path

packages/opencode/src/util/queue.ts

• adds a queue head index instead of removing from the front of the array with shift()
• compacts the backing array only when enough items have been consumed to make compaction worthwhile
• keeps ordering semantics and waiter handoff behavior unchanged

packages/opencode/test/util/queue.test.ts

• verifies long ordered dequeue behavior
• verifies waiting readers still receive pushed values correctly

3. Processor cleanup avoids redundant reads

packages/opencode/src/session/processor.ts

• cleanup now iterates the in-memory ctx.toolcalls map rather than rereading all parts for the assistant message
• only unfinished in-memory tool calls are converted to terminal error state during abort / cleanup
• explicitly leaves the existing doom-loop detection semantics intact

Scope

This PR is intentionally limited to packages/opencode/** hot-path infrastructure.
It does not include the unrelated local packages/console/** changes currently present in my working tree.

Validation

Typecheck

Run from packages/opencode:

• bun typecheck

Targeted tests

Run from packages/opencode:

• bun test test/session/summary.test.ts test/util/queue.test.ts test/session/processor-effect.test.ts

Result:

• all targeted tests passed

Manual QA

Run from packages/opencode:

• bun -e 'import { AsyncQueue } from "./src/util/queue"; const q = new AsyncQueue(); q.push("a"); q.push("b"); console.log([await q.next(), await q.next()].join(","))'
  • output: a,b
• summary single-flight probe against SessionSummary.layer
  • output: summary_messages:1
  • output: summary_calls:1

Microbench checks

Run from packages/opencode:

• queue comparison over 200000 push+pop operations
  • shift:18.13ms
  • idx:12.73ms
• warmed tool-registry benchmark used during validation of the broader hot-path investigation
  • warm_same:24.12ms
  • vary_agent:32.38ms

Trade-offs / things to watch

• summary single-flight state is bounded to 1024 keys and invalidated after completion, so it should not become a persistent result cache
• queue compaction trades occasional slice work for much cheaper steady-state dequeue behavior
• processor cleanup now trusts the authoritative in-memory in-flight tool map during teardown, which is the same state the stream handler mutates during execution

Follow-up measurement plan

After merge, the next useful measurement is an end-to-end agent-loop benchmark on a fixed fixture repo that captures:

• wall-clock latency per loop iteration
• CPU time
• RSS / heap growth under repeated runs
• count of summary invocations and tool-cleanup reads

That follow-up would quantify how much these micro-optimizations move real session throughput under realistic load.

[github-actions]

Hey! Your PR title perf(opencode): reduce redundant summary and queue overhead doesn't follow conventional commit format.

Please update it to start with one of:

• feat: or feat(scope): new feature
• fix: or fix(scope): bug fix
• docs: or docs(scope): documentation changes
• chore: or chore(scope): maintenance tasks
• refactor: or refactor(scope): code refactoring
• test: or test(scope): adding or updating tests

Where scope is the package name (e.g., app, desktop, opencode).

See CONTRIBUTING.md for details.

[github-actions]

This PR doesn't fully meet our contributing guidelines and PR template.

What needs to be fixed:

• PR description is missing required template sections. Please use the PR template.

Please edit this PR description to address the above within 2 hours, or it will be automatically closed.

If you believe this was flagged incorrectly, please let a maintainer know.

[github-actions]

The following comment was made by an LLM, it may be inaccurate:

Potential Related PR Found

PR #20303: refactor(opencode): optimize doom loop detection, summary debounce, parallel plugin events
#20303

This PR may be related because it also addresses summary debouncing/optimization in opencode, which overlaps with PR #21507's work on reducing redundant summary calls and processor cleanup. However, the exact relationship (whether closed, merged, or addressing different aspects) should be verified.

PR #19237: perf(opencode): reduce streaming latency and request overhead
#19237

This PR addresses similar hot-path performance concerns in opencode streaming, though focused on a different area.

[github-actions]

This pull request has been automatically closed because it was not updated to meet our contributing guidelines within the 2-hour window.

Feel free to open a new pull request that follows our guidelines.