GeezerVison

Previously, taking a queued message immediately moved it into the transcript, even when Claude Code had not consumed it yet. This change introduces an acknowledgment callback and an in-flight collection: those messages remain visible as non-editable steering entries until acknowledged, return to the queue if rejected, or become transcript items when the turn ends without an acknowledgment. It also updates the documentation and release notes.

Changes

Sequence diagram

sequenceDiagram
    participant Actor as Session actor
    participant Engine as Claude engine
    participant Claude as Claude Code
    Engine->>Actor: takeQueued({whileTools: true})
    Actor-->>Engine: Message with read callback
    Note over Actor: Keep visible as steering; disallow editing
    Engine->>Claude: User message with command UUID
    Claude-->>Engine: command_lifecycle
    alt Message started
        Engine->>Actor: read(true)
        Note over Actor: Remove steering entry and emit transcript item
    else Message dropped
        Engine->>Actor: read(false)
        Note over Actor: Return entry to pending queue
    end

• Files reviewed: 8 · 125 changed lines · estimated review effort 2/5, about 15 minutes
• Profile: normal · at most 8 inline comments
• Verification: every finding was checked again by a separate pass (1 candidate judged)
• Cost: 470,845 tokens in (367,104 from the provider's cache) · 3,987 out
• Readers: 4 files went to readers instead of the review pass whole: 4 code files by gpt-6-luna (the review pass gets their summaries and the hunks of their risk spots; 1 call, up to 3 at once, 11,731 tokens counted). Their summaries are hints, not findings. 4 code files no reader could read went to the review pass whole (the reader gave no usable answer for this file; the reader flagged more risk spots than a summary carries, so the file goes whole).
• Stacked on #152: only this pull request's own commits since #152's head 2770e95.

Performance (perf-attrib, base 2770e95 against head 92f2f24)

perf-attrib: baja: tui.after.heap.protected -1

base 2770e953f006908a800ac9b63b04079013263ea2 (2770e953) vs cand 92f2f24a92209d32b7dc128c94671afadacc0b09 (92f2f24a), median of 2 faux-engine session(s) per side; flagged = beyond the noise measured on 18 base-vs-base runs (x1.5).

JS object types that rose (count):

• tui.ready.heap.type.Array: 7567 -> 7568 (+1)
• tui.after.heap.type.Array: 8519 -> 8520 (+1)
• tui.rest.heap.type.Function: 44733 -> 44734 (+1)
• tui.rest.heap.type.Array: 8518 -> 8519 (+1)

JS heap bytes by constructor that rose:

• tui.rest.ctor.object:ModuleRecord.bytes: 5512779 -> 5513913 (+1134)
• tui.rest.ctor.native:Blob.bytes: 1745343 -> 1745948 (+605)
• tui.rest.ctor.closure:N.bytes: 2496 -> 2528 (+32)
• tui.rest.ctor.closure:U.bytes: 2368 -> 2400 (+32)

Modules loaded at start: 231 -> 231, 4639641 -> 4640775 bytes of chunks; chunk sizes only in cand: [29263], only in base: [28129] (chunk names are hashes: the list says which changed in size, not by what name)

Reference (skill, 2026-11-03, real model): footprint 64 ready / 66 after / peak 80 MB, 2.6 KB per session. This run (faux engine, whole process tree): 54.6 / 57.4 / peak 73.2 MB, 2058 B per session.

This increment completes the existing steering-message behavior rather than introducing the underlying unread-message tracking. Queue admission now counts both queued messages and messages already handed to the engine but not yet read. Resolving the final pending approval also retries the engine notification so a message queued during approval can be taken while tools run. The Discord test uses a distinctive owner identifier to prevent unrelated report content from falsely triggering its privacy assertion.

Changes

Sequence diagram

sequenceDiagram
    participant User
    participant Actor as Session actor
    participant Engine as Claude Code adapter
    User->>Actor: Queue message while approval is pending
    Engine->>Actor: takeQueued(whileTools)
    Actor-->>Engine: No message while approval is pending
    User->>Actor: Resolve final pending approval
    Actor->>Engine: Resolve approval promise
    Actor->>Engine: onQueued callback
    Engine->>Actor: takeQueued(whileTools)
    Actor-->>Engine: Eligible message with read callback
    Note over Actor: Unread message still counts toward queue limit

• Files reviewed: 3 · 44 changed lines · estimated review effort 1/5, about 5 minutes
• Profile: normal · at most 8 inline comments
• Verification: the review pass raised no candidate findings, so no separate pass was needed
• Cost: 345,829 tokens in (297,856 from the provider's cache) · 1,605 out
• Readers: 3 code files no reader could read went to the review pass whole (the diff is small: one reader call costs more than the readers' share of this review's cap, so the review pass reads it).

Performance (perf-attrib, base 2770e95 against head 1a529ca)

perf-attrib: igual: nothing above the measured noise

base 2770e953f006908a800ac9b63b04079013263ea2 (2770e953, cached build) vs cand 1a529ca1ecd75b915053d67d72e394456473d44d (1a529ca1), median of 2 faux-engine session(s) per side; flagged = beyond the noise measured on 18 base-vs-base runs (x1.5).

JS object types that rose (count):

• tui.after.heap.type.Function: 44735 -> 44737 (+2)
• tui.after.heap.type.StructureChain: 91 -> 93 (+2)
• tui.rest.heap.type.Function: 44732 -> 44734 (+2)
• tui.rest.heap.type.StructureChain: 90 -> 92 (+2)

JS heap bytes by constructor that rose:

• tui.rest.ctor.object:ModuleRecord.bytes: 5512779 -> 5513939 (+1160)
• tui.rest.ctor.native:Blob.bytes: 1745343 -> 1745948 (+605)
• tui.rest.ctor.closure:Function.bytes: 851042 -> 851074 (+32)
• tui.rest.ctor.closure:N.bytes: 2496 -> 2528 (+32)

Modules loaded at start: 231 -> 231, 4639641 -> 4640801 bytes of chunks; chunk sizes only in cand: [29289], only in base: [28129] (chunk names are hashes: the list says which changed in size, not by what name)

Reference (skill, 2026-11-03, real model): footprint 64 ready / 66 after / peak 80 MB, 2.6 KB per session. This run (faux engine, whole process tree): 54.9 / 57.8 / peak 73.1 MB, 2052 B per session.

The CLI now accepts --fast for terminal startup, headless runs, session creation, and session submission, validates model support, and passes fast mode through the existing model-choice contract. Channel changes release topic resources on eviction and shutdown, acknowledge Discord button presses before the serialized update queue, avoid opening an already-cancelled gateway, and improve Telegram formatting fallback. Documentation and regression tests accompany these changes; the generated cards file changes only its revision.

Changes

Sequence diagram

sequenceDiagram
  participant CLI
  participant Daemon
  participant Gateway as Discord gateway
  participant Transport
  participant Discord as Discord REST
  participant Bridge
  CLI->>Daemon: models.list for --fast
  Daemon-->>CLI: Catalog and selected model
  CLI->>Daemon: Create, set, or submit model choice with fast=true
  Gateway->>Transport: INTERACTION_CREATE
  Transport->>Discord: Start acknowledgment immediately
  Transport->>Transport: Enqueue dispatch
  Transport->>Bridge: Process button press
  Bridge->>Discord: Send follow-up through channel adapter

• Files reviewed: 15 · 169 changed lines · estimated review effort 2/5, about 15 minutes
• Profile: normal · at most 8 inline comments
• Verification: every finding was checked again by a separate pass (1 candidate judged)
• Cost: 674,024 tokens in (585,600 from the provider's cache) · 4,353 out
• Readers: 12 files went to readers instead of the review pass whole: 12 code files by gpt-6-luna (the review pass gets their summaries and the hunks of their risk spots; 1 call, up to 3 at once, 18,753 tokens counted). Their summaries are hints, not findings. 3 code files no reader could read went to the review pass whole (the reader gave no usable answer for this file).

Performance (perf-attrib, base 2770e95 against head 6db8994)

perf-attrib: nota: no total rose; inside, tui.ready.heap.objects +167; tui.ready.heap.size_b +57884B

base 2770e953f006908a800ac9b63b04079013263ea2 (2770e953, cached build) vs cand 6db8994c1da4ab03dc4cb8f87cb436901bd32ad5 (6db8994c), median of 2 faux-engine session(s) per side; flagged = beyond the noise measured on 18 base-vs-base runs (x1.5).

JS object types that rose (count):

• tui.ready.heap.type.string: 19849 -> 19883 (+34)
• tui.ready.heap.type.UnlinkedFunctionExecutable: 14155 -> 14181 (+26)
• tui.ready.heap.type.FunctionExecutable: 14169 -> 14194 (+25)
• tui.ready.heap.type.SymbolTable: 3418 -> 3431 (+13)

JS heap bytes by constructor that rose:

• tui.rest.ctor.object:ModuleRecord.bytes: 5512779 -> 5516089 (+3310)
• tui.rest.ctor.native:Blob.bytes: 1745343 -> 1746154 (+811)
• tui.rest.ctor.object:Object.bytes: 1418734 -> 1418894 (+160)
• tui.rest.ctor.code:ModuleProgramExecutable.bytes: 24192 -> 24304 (+112)

Modules loaded at start: 231 -> 232, 4639641 -> 4641718 bytes of chunks; chunk sizes only in cand: [1008448, 715903, 161646, 74411, 29289, 5132, 3554, 2313], only in base: [1008429, 716593, 161443, 74254, 28129, 5005, 3515, 2087] (chunk names are hashes: the list says which changed in size, not by what name)

Reference (skill, 2026-11-03, real model): footprint 64 ready / 66 after / peak 80 MB, 2.6 KB per session. This run (faux engine, whole process tree): 54.9 / 56.9 / peak 72.8 MB, 2058 B per session.

This review covers only the supplied incremental diff, not the previously reviewed stacked changes. Discord acknowledgement tracking now retains a shared promise for each recent interaction rather than just its ID, allowing dispatch to await the same request initiated when the gateway event arrives. The regression test delays acknowledgement completion and checks that dispatch remains pending without issuing a second acknowledgement. Queue steering, Telegram behavior, fast-mode flags, and release metadata are untouched by this increment.

Changes

Sequence diagram

sequenceDiagram
    participant G as Discord gateway
    participant T as Discord transport
    participant C as Discord channel
    participant D as Discord REST API
    participant B as Channel bridge
    G->>T: INTERACTION_CREATE
    T->>C: acknowledge(event)
    C->>D: Initial callback
    C-->>T: Cached promise (not awaited)
    T->>C: dispatch(event), in update order
    C->>C: Await cached acknowledgement promise
    D-->>C: Callback completes
    C-->>T: Press update
    T->>B: onUpdate(press)
    B->>C: answerCallback(id, text)
    C->>D: Follow-up response

• Files reviewed: 3 · 25 changed lines · estimated review effort 1/5, about 5 minutes
• Profile: normal · at most 8 inline comments
• Verification: the review pass raised no candidate findings, so no separate pass was needed
• Cost: 119,747 tokens in (97,536 from the provider's cache) · 1,417 out
• Readers: 3 code files no reader could read went to the review pass whole (the diff is small: one reader call costs more than the readers' share of this review's cap, so the review pass reads it).

Performance (perf-attrib, base 2770e95 against head 1de4782)

perf-attrib: igual: nothing above the measured noise

base 2770e953f006908a800ac9b63b04079013263ea2 (2770e953, cached build) vs cand 1de4782f0f8093dd907488e13f07399c928ac6f2 (1de4782f), median of 2 faux-engine session(s) per side; flagged = beyond the noise measured on 18 base-vs-base runs (x1.5).

JS object types that rose (count):

• tui.ready.heap.type.SymbolTable: 3428 -> 3431 (+3)
• tui.ready.heap.type.InternalPromise: 695 -> 698 (+3)
• tui.after.heap.type.Function: 44737 -> 44740 (+3)
• tui.after.heap.type.InternalPromise: 704 -> 707 (+3)

JS heap bytes by constructor that rose:

• tui.rest.ctor.object:ModuleRecord.bytes: 5512779 -> 5516089 (+3310)
• tui.rest.ctor.native:Blob.bytes: 1745343 -> 1746154 (+811)
• tui.rest.ctor.object:Object.bytes: 1418734 -> 1418894 (+160)
• tui.rest.ctor.code:ModuleProgramExecutable.bytes: 24192 -> 24304 (+112)

Modules loaded at start: 231 -> 232, 4639641 -> 4641718 bytes of chunks; chunk sizes only in cand: [1008448, 715903, 161646, 74411, 29289, 5132, 3554, 2313], only in base: [1008429, 716593, 161443, 74254, 28129, 5005, 3515, 2087] (chunk names are hashes: the list says which changed in size, not by what name)

Reference (skill, 2026-11-03, real model): footprint 64 ready / 66 after / peak 80 MB, 2.6 KB per session. This run (faux engine, whole process tree): 54.8 / 56.8 / peak 72.8 MB, 2057 B per session.