feat: add chime-in — bot organically joins conversations

[BillChirico]

Summary

Adds a chime-in feature that lets the bot automatically participate in guild conversations without being explicitly @mentioned.

How it works

• Ring buffer accumulates messages per channel (capped at 30)
• After every 10 messages, a cheap Haiku LLM call evaluates: "Should I chime in?"
• YES → generates a full response via existing AI pipeline, sends as a plain message
• NO → resets counter, keeps buffer for context continuity
• Counter resets on @mention to prevent double-responding

Key design decisions

• No fixed trigger — the LLM decides if it's worth contributing
• Concurrent evaluation guard prevents race conditions on busy channels
• Evaluation uses maxTokens: 10 (just YES/NO) for minimal cost
• Response sends as plain channel message, not a reply

Files changed

• src/modules/chimeIn.js — New module (207 lines)
• src/modules/events.js — Integration hooks
• config.json — Added chimeIn config section

Config

"chimeIn": {
  "enabled": true,
  "evaluateEvery": 10,
  "model": "claude-haiku-4-5",
  "maxBufferSize": 30,
  "channels": [],
  "excludeChannels": []
}

Inspired by openclaw/openclaw#10652.

[coderabbitai]

Warning

Rate limit exceeded

@BillChirico has exceeded the limit for the number of commits that can be reviewed per hour. Please wait 16 minutes and 25 seconds before requesting another review.

⌛ How to resolve this issue?

After the wait time has elapsed, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

We recommend that you space out your commits to avoid hitting the rate limit.

🚦 How do rate limits work?

CodeRabbit enforces hourly rate limits for each developer per organization.

Our paid plans have higher rate limits than the trial, open-source and free plans. In all cases, we re-allow further reviews after a brief timeout.

Please see our FAQ for further information.

📥 Commits

Reviewing files that changed from the base of the PR and between 6d124c4 and a15068e.

📒 Files selected for processing (3)

• src/modules/chimeIn.js
• src/modules/events.js
• src/utils/splitMessage.js

📝 Walkthrough

Walkthrough

Adds a top-level chimeIn configuration, implements a new chime-in module that buffers per-channel messages and autonomously evaluates/responds, integrates it into message event handling to avoid duplicate replies, and exports OPENCLAW_URL and OPENCLAW_TOKEN from ai.js.

Changes

Cohort / File(s)	Summary
Configuration config.json	Added top-level chimeIn block with enabled, evaluateEvery, model, maxBufferSize, channels, and excludeChannels.
Chime-in Module src/modules/chimeIn.js	New module implementing per-channel ring buffers, evaluation cadence, cheap LLM decision call, response generation (chunking), concurrency guards (per-channel locks + AbortController), eviction/pruning logic, and robust error handling. Exports accumulate(message, config) and resetCounter(channelId).
Event Integration src/modules/events.js	Imports accumulate and resetCounter; resets chime-in counter before direct AI replies, returns early after direct replies to avoid double responses, and calls accumulate (fire-and-forget) for other messages with error logging.
AI Config Exports src/modules/ai.js	Exposes OPENCLAW_URL and OPENCLAW_TOKEN as exported constants (no behavioral change).

Sequence Diagram

sequenceDiagram
    participant Message as Message Event
    participant Events as events.js
    participant ChimeIn as chimeIn Module
    participant EvalLLM as Evaluation LLM
    participant AI as AI Response Engine
    participant Channel as Discord Channel

    Message->>Events: messageCreate event
    Events->>ChimeIn: accumulate(message, config)
    ChimeIn->>ChimeIn: append to per-channel buffer
    ChimeIn->>ChimeIn: check evaluateEvery counter
    alt Evaluation triggered
        ChimeIn->>EvalLLM: send lightweight evaluation request
        EvalLLM-->>ChimeIn: YES / NO
        alt YES
            ChimeIn->>AI: request contextual response
            AI-->>ChimeIn: response content
            ChimeIn->>Channel: post autonomous message
            ChimeIn->>ChimeIn: reset counter
        else NO
            ChimeIn->>ChimeIn: reset counter (keep buffer)
        end
    end
    Events->>ChimeIn: resetCounter(channelId)  Note: on direct bot reply to avoid duplicates

Loading

Estimated code review effort

🎯 4 (High) | ⏱️ ~60 minutes

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title 'feat: add chime-in — bot organically joins conversations' clearly describes the main feature being added and aligns well with the substantial changes in the changeset.
Description check	✅ Passed	The description provides a comprehensive overview of the chime-in feature, explaining how it works, key design decisions, files changed, and configuration, which directly relates to the changeset modifications.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch feat/chime-in

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 8

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/modules/events.js (1)

69-83: ⚠️ Potential issue | 🟠 Major

Race condition: accumulate can trigger a chime-in and the mention handler fires simultaneously.

accumulate() is invoked fire-and-forget on Line 70. If the counter has already reached evaluateEvery, the async evaluation starts immediately. Then on Line 83, resetCounter() sets the counter to 0, but the in-flight evaluation is already past the counter check and will proceed to generate and send a chime-in response. Meanwhile, the mention handler below also generates a response — resulting in two bot messages for the same trigger message.

Consider one of:

1. await the accumulate call before entering the mention branch, so evaluation completes (and possibly chimes in) before the mention path runs — then skip the mention response if a chime-in just fired.
2. Move accumulate() after the mention check, only calling it when the message is not a mention/reply. This is the simplest fix and aligns with the stated goal of avoiding double responses.

Option 2: only accumulate when the message is not a mention

     // AI chat - respond when mentioned
     if (config.ai?.enabled) {
       const isMentioned = message.mentions.has(client.user);
       const isReply = message.reference && message.mentions.repliedUser?.id === client.user.id;

       // Check if in allowed channel (if configured)
       const allowedChannels = config.ai?.channels || [];
       const isAllowedChannel = allowedChannels.length === 0 || allowedChannels.includes(message.channel.id);

       if ((isMentioned || isReply) && isAllowedChannel) {
         // Reset chime-in counter so we don't double-respond
         resetCounter(message.channel.id);

         // ... existing mention handling ...
+      } else {
+        // Chime-in: accumulate message for organic participation (fire-and-forget)
+        accumulate(message, client, config, healthMonitor).catch((err) => {
+          console.error('ChimeIn accumulate error:', err);
+        });
       }
+    } else {
+      // AI disabled — still accumulate for chime-in if configured independently
+      accumulate(message, client, config, healthMonitor).catch((err) => {
+        console.error('ChimeIn accumulate error:', err);
+      });
     }

🤖 Fix all issues with AI agents

In `@config.json`:
- Around line 9-16: The chimeIn config is too aggressive: change the default
"evaluateEvery" from 1 to 10 and make "enabled" false by default unless
explicitly turned on or a non-empty "channels" list is provided; update the
"chimeIn" block so evaluateEvery: 10 and enabled: false (or add validation that
prevents enabled:true when "channels" is empty and evaluateEvery is below a safe
threshold), referencing the "chimeIn", "evaluateEvery", "enabled", and
"channels" keys to locate the setting.

In `@src/modules/chimeIn.js`:
- Around line 56-74: The current shouldChimeIn flow forwards raw
conversationText (from buffer.messages) before the system instruction, which
makes the YES/NO decision vulnerable to prompt injection; modify the messages
construction so the user conversation is clearly separated (e.g., wrap
conversationText with a structured delimiter/fence like "-----BEGIN
CONVERSATION-----" / "-----END CONVERSATION-----") and place the system
directive (the object with role: 'system' and the YES/NO instruction used by
shouldChimeIn) after that delimited user content so the evaluation model sees
the system policy last and cannot be overridden by user-supplied content.
- Around line 15-20: channelBuffers currently grows without bounds because
entries are never evicted; update the per-channel state stored in channelBuffers
to include a lastActivity timestamp (e.g., store {messages, counter,
lastActivity}) and implement an eviction policy: either enforce a max size LRU
by moving touched keys to the Map's end and trimming oldest entries when adding
in the function that updates channelBuffers, or add a periodic cleanup task
(setInterval) that removes channels whose lastActivity is older than N minutes;
ensure related logic that checks/uses channelBuffers and evaluatingChannels
(same names) gracefully handles removed entries (e.g., clear evaluatingChannels
for pruned channels).
- Line 117: The accumulate function currently declares an unused parameter
client; remove client from the accumulate function signature (export async
function accumulate(message, config, healthMonitor)) and update all call sites
(notably the call in events.js that currently passes client) to stop passing
that extra argument, and update any related JSDoc/comments to reflect the new
parameter list; run tests/lint to ensure no other references remain.
- Around line 160-168: The generateResponse call in chimeIn.js can hang and
leave the channel locked in evaluatingChannels; wrap the generateResponse
promise with a timeout (e.g., Promise.race against a timeout-rejecting Promise)
or ensure generateResponse itself accepts/implements a timeout option, then
handle the timeout by removing channelId from evaluatingChannels and
returning/logging a timeout error; specifically update the call that passes
channelId, contextMessage, '_chime-in_', config, healthMonitor so it either uses
a timed wrapper or a new timeout param to generateResponse and guarantees
cleanup of evaluatingChannels on timeout.
- Around line 127-136: The ring buffer is storing messages with empty string
content (attachments/embeds only), wasting slots; before pushing into
buf.messages in the push block, guard by checking message.content.trim() is
non-empty (i.e., only push if message.content && message.content.trim() !== ''),
so attachment-only or embed-only messages are skipped; keep the existing
trimming loop (while buf.messages.length > maxBufferSize { buf.messages.shift()
}) unchanged.
- Around line 77-103: The fetch to OPENCLAW_URL (using OPENCLAW_TOKEN, model,
messages) needs a request timeout to avoid hanging; wrap the fetch in an
AbortController (or use AbortSignal.timeout) and pass signal to fetch, start a
setTimeout to call controller.abort() after a configurable ms, and clear that
timer on success/failure so the controller is cleaned up; ensure the catch
handles AbortError the same way and the function still returns false on timeout
to allow the evaluate/accumulate logic (e.g., evaluatingChannels) to release the
channel.

In `@src/modules/events.js`:
- Around line 69-71: The call to the async function accumulate(message, client,
config, healthMonitor) is fire-and-forget and may produce unhandled promise
rejections if it throws before its internal try block; wrap the call with a
rejection handler (e.g., accumulate(...).catch(err => { /* log error via
healthMonitor or process logger */ })) or explicitly await it where appropriate,
ensuring you log the error and include context (message/client/config) so
unexpected TypeError or other sync throws are caught; update the call site that
invokes accumulate(...) accordingly.

📜 Review details

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 5c85a3d and 395bf52.

📒 Files selected for processing (3)

• config.json
• src/modules/chimeIn.js
• src/modules/events.js

🧰 Additional context used

🧬 Code graph analysis (1)

src/modules/events.js (1)

src/modules/chimeIn.js (2)

• accumulate (117-194)
• resetCounter (202-207)

🔇 Additional comments (6)

src/modules/events.js (1)

9-9: LGTM on the import.

Clean import of the two public exports from the new module.

src/modules/chimeIn.js (5)

28-36: LGTM. Standard get-or-create pattern.

---

38-51: LGTM. Exclusion-first logic is clean, and the empty allow-list convention is consistent with the existing AI channel config.

---

148-193: Overall evaluation/response flow is well-structured.

The concurrency guard, try/catch/finally cleanup, counter-reset-on-error, and buffer-clear-on-success semantics are all sound. The separation between "YES → clear buffer" and "NO → keep buffer, reset counter" provides good context continuity.

---

196-207: resetCounter does not cancel in-flight evaluations.

This is the flip side of the race condition noted in events.js: calling resetCounter while an evaluation is already in progress has no effect on that evaluation — it will still generate and send a chime-in response. If the double-response race is addressed in the caller (recommended), this function is fine as-is. Otherwise, consider also checking/clearing the evaluatingChannels entry here and aborting the in-flight fetch via an AbortController stored per channel.

---

1-13: Clean module structure and documentation.

The header comment, imports, and overall organization are well done. The separation of concerns (helpers, evaluation, public API) is clear.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/modules/chimeIn.js`:
- Around line 154-173: The code creates a redundant manual timeout
(timeoutPromise + Promise.race) around fetchPromise which already uses
AbortSignal.timeout(30_000), risking unhandled rejections if the manual timeout
wins; remove the timeoutPromise and the Promise.race call and instead await
fetchPromise directly (keep the AbortSignal.timeout on the fetch so the request
is aborted correctly), delete the setTimeout that constructs timeoutPromise, and
ensure any fetch rejections from fetchPromise are caught/handled where response
is used.
- Line 193: The accumulate function currently accepts a healthMonitor parameter
but never uses it; either remove healthMonitor from accumulate's signature and
all call sites in events.js, or integrate it into the API workflow by
instrumenting the calls that generateChimeInResponse makes (mirroring
generateResponse in ai.js): call healthMonitor.recordAIRequest() before the
external request, wrap the HTTP call to OPENCLAW_URL and call
healthMonitor.setAPIStatus(success|failure) based on the response or caught
error, and ensure healthMonitor is forwarded into generateChimeInResponse so the
monitoring methods are invoked there.

📜 Review details

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 395bf52 and af2a78d.

📒 Files selected for processing (4)

• config.json
• src/modules/ai.js
• src/modules/chimeIn.js
• src/modules/events.js

🧰 Additional context used

🧬 Code graph analysis (2)

src/modules/chimeIn.js (2)

src/modules/ai.js (6)

• messages (78-82)
• response (88-99)
• OPENCLAW_URL (29-29)
• OPENCLAW_URL (29-29)
• OPENCLAW_TOKEN (30-30)
• OPENCLAW_TOKEN (30-30)

src/logger.js (2)

• warn (225-227)
• info (218-220)

src/modules/events.js (1)

src/modules/chimeIn.js (2)

• resetCounter (277-282)
• accumulate (193-269)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Cursor Bugbot

🔇 Additional comments (9)

src/modules/ai.js (1)

28-30: LGTM — exporting shared API constants avoids duplication.

Clean approach to share the endpoint/token with the new chimeIn module rather than duplicating the env-var reads.

config.json (1)

9-16: Safe defaults — previous review concerns addressed.

enabled: false and evaluateEvery: 10 are sensible production-safe defaults.

src/modules/events.js (2)

69-80: Correct placement of resetCounter — prevents double responses.

Resetting the chime-in counter immediately upon detecting a mention, before generating the AI response, correctly avoids the race where a chime-in evaluation could fire while the mention response is in flight.

---

111-119: Clean integration — early return and .catch() are both correct.

The return on line 112 correctly prevents mentioned messages from also being accumulated into the chime-in buffer. The .catch() on accumulate() addresses the previously flagged fire-and-forget concern.

src/modules/chimeIn.js (5)

1-24: Well-structured module header and state declarations.

Clean separation of concerns with per-channel state, concurrency guard, and configurable eviction constants. The 100-channel LRU cap and 30-minute inactivity timeout are reasonable defaults for a Discord bot.

---

31-48: Eviction logic is sound.

Inactive-channel pruning followed by LRU overflow eviction is a clean two-pass approach. Map deletion during for...of iteration is safe per the JS spec.

---

53-76: LGTM — getBuffer and isChannelEligible are clean.

Eviction is triggered only on new-channel insertion (line 55), avoiding unnecessary overhead. Channel eligibility logic correctly gives excludeChannels priority over the allow-list.

---

81-131: Evaluation function is well-guarded.

10s timeout, max_tokens: 10, safe false default on error, and startsWith('YES') parsing are all solid choices for a cheap gate-keeping call.

---

277-292: LGTM — simple, correct public API helpers.

resetCounter and isEvaluating are minimal and correct.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/modules/chimeIn.js`:
- Around line 232-245: The current startsWith-based suppression
(response.startsWith('Sorry, I') / response.startsWith('Error')) is brittle;
update the logic in the block that decides whether to send messages (the code
using response, warn, and message.channel.send) to only suppress truly empty or
whitespace-only responses and/or rely on an explicit error signal from the
upstream API (e.g., a response.error flag or status code) instead of
string-prefix matching; remove or make the string heuristics configurable (e.g.,
a blacklist array or option) and ensure chunking via response.match and sending
via message.channel.send remains unchanged for valid responses.
- Around line 137-174: The generateChimeInResponse function currently injects
raw conversationText into the user prompt; update generateChimeInResponse to
wrap conversationText with the same structured delimiter used in shouldChimeIn
(e.g., surround the conversation with "<conversation>" and "</conversation>")
before building the messages array so the user message uses the delimited block,
keeping the rest of the systemPrompt/messages construction, model, and fetch
logic unchanged.

📜 Review details

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between af2a78d and 2161caa.

📒 Files selected for processing (2)

• src/modules/chimeIn.js
• src/modules/events.js

🧰 Additional context used

🧬 Code graph analysis (2)

src/modules/chimeIn.js (2)

src/modules/ai.js (9)

• systemPrompt (72-75)
• messages (78-82)
• response (88-99)
• OPENCLAW_URL (29-29)
• OPENCLAW_URL (29-29)
• OPENCLAW_TOKEN (30-30)
• OPENCLAW_TOKEN (30-30)
• data (108-108)
• reply (109-109)

src/logger.js (2)

• warn (225-227)
• info (218-220)

src/modules/events.js (1)

src/modules/chimeIn.js (2)

• resetCounter (269-274)
• accumulate (185-261)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Cursor Bugbot

🔇 Additional comments (6)

src/modules/events.js (1)

9-9: Chime-in integration looks clean.

The flow is well-structured: counter reset before mention processing prevents double-responses, the guard return on Line 112 correctly excludes direct mentions from the chime-in buffer, and the fire-and-forget .catch() addresses the previously flagged unhandled rejection concern. The accumulate call signature now correctly matches the updated (message, config) parameters.

Also applies to: 79-80, 111-112, 116-119

src/modules/chimeIn.js (5)

1-24: Module structure and state management look solid.

Clean separation of concerns with well-documented module header. The LRU eviction constants (MAX_TRACKED_CHANNELS, CHANNEL_INACTIVE_MS) address the previously flagged unbounded memory growth concern.

---

31-61: Eviction and buffer management are correct.

evictInactiveChannels properly handles both time-based and size-based eviction. Deleting from a Map during for...of iteration is safe per the JS spec. getBuffer triggers eviction only on new channel creation, avoiding unnecessary work on every access.

---

185-261: Concurrency guard and error handling are well-structured.

The evaluatingChannels Set + try/finally pattern correctly prevents concurrent evaluations and guarantees cleanup. Counter reset on error (Line 257) prevents spin-looping. The early-return cascade (disabled → ineligible → empty → below threshold → already evaluating) is clean and efficient.

One minor note: messages arriving during an ongoing evaluation still push into buf.messages and increment buf.counter (lines 199–210 execute before the guard at line 216). When the evaluation completes and resets the counter, those interim increments are lost. This is acceptable behavior but worth being aware of — under heavy traffic during a slow evaluation, the effective evaluation cadence will be longer than evaluateEvery.

---

269-274: LGTM.

Simple and correct. No-op when the channel has no buffer is the right behavior.

---

92-101: This message ordering is already intentional—review the comment on line 91.

The code deliberately places user before system with an explicit comment explaining it's for prompt injection mitigation. This differs from the standard ordering in ai.js (line 78–82), where system comes first. Since OpenClaw is OpenAI-compatible and the code is already deployed, the backend evidently respects trailing system messages. Consider documenting this design choice or adding a comment referencing OpenClaw's message-ordering behavior if clarity is needed for future maintainers.

Likely an incorrect or invalid review comment.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

[coderabbitai]

Actionable comments posted: 3

🤖 Fix all issues with AI agents

In `@src/modules/chimeIn.js`:
- Around line 15-17: The JSDoc type for channelBuffers is missing the
abortController field; update the inline type annotation for the Map (the
comment on the Map<channelId, { ... }>) to include abortController:
AbortController (or nullable) alongside messages, counter, and lastActive so it
matches the actual stored object used elsewhere (see channelBuffers and the
abortController assigned around where fetch/stream is started). Ensure the
symbol names remain messages, counter, lastActive, and abortController to keep
the annotation accurate.
- Around line 253-257: The current chunking in chimeIn.js uses /[\s\S]{1,1990}/g
which can break mid-word/URL/emoji; update the logic that builds chunks from the
response (the variable named "response" and the "chunks" array used before
calling message.channel.send) to split on natural boundaries—preferably break on
newline or whitespace boundaries (e.g., accumulate words/lines until adding the
next would exceed 1990 chars, then start a new chunk) so each chunk ends at a
space or newline; ensure you keep the 1990 char limit and that the for-loop
sending via message.channel.send remains unchanged.
- Around line 219-246: The AbortController created as abortController is only
checked between steps and its signal is never passed into the HTTP-requesting
functions, so shouldChimeIn and generateChimeInResponse continue running even
after resetCounter aborts; update shouldChimeIn(...) and
generateChimeInResponse(...) call sites to accept an AbortSignal (e.g., pass
abortController.signal) and ensure the internal fetch/http calls use that signal
(and merge it with any timeout logic using AbortSignal.any on Node ≥18.17.0 or
by creating a per-request AbortController that you abort from
abortController.signal.onabort for older Node), keeping the existing
abortController.signal checks as fallback and ensuring request-level
cancellation actually aborts network I/O.

📜 Review details

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 2161caa and 85b425b.

📒 Files selected for processing (1)

• src/modules/chimeIn.js

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Cursor Bugbot

🔇 Additional comments (6)

src/modules/chimeIn.js (6)

1-14: Clean module header and imports.

Well-structured module documentation that clearly explains the feature's behavior. Imports are minimal and relevant.

---

31-48: Eviction logic is sound.

Inactivity-based eviction followed by LRU-style overflow eviction is a clean approach. Map deletion during for...of iteration is safe in JavaScript.

---

63-76: LGTM — clear inclusion/exclusion logic.

---

81-131: Evaluation function looks solid.

Good use of AbortSignal.timeout, structured <conversation> delimiters, system-instruction-last ordering, and safe fallback to false on error.

---

137-174: Response generation function is well-structured.

Separate AI context avoids polluting shared history. Timeouts and <conversation> delimiters are in place.

---

279-296: resetCounter cleanly cancels in-flight evaluations.

Properly resets the counter and aborts any pending evaluation to prevent double-responses on @mention.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@src/modules/chimeIn.js`:
- Around line 261-274: The fallback hard-cut at splitAt = 1990 can split UTF-16
surrogate pairs (e.g., emoji); modify the fallback logic around splitAt (used
with remaining.lastIndexOf and remaining.slice) to ensure you never cut in the
middle of a surrogate pair: when splitAt <= 0 and you set splitAt = 1990, check
surrounding code units via remaining.charCodeAt(splitAt - 1) /
charCodeAt(splitAt) and, if the cut would split a surrogate pair (high surrogate
at split boundary), decrement splitAt until the boundary is safe (or > 0) before
slicing and pushing the chunk.

📜 Review details

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 85b425b and 6d124c4.

📒 Files selected for processing (1)

• src/modules/chimeIn.js

🧰 Additional context used

🧬 Code graph analysis (1)

src/modules/chimeIn.js (2)

src/modules/ai.js (7)

• systemPrompt (72-75)
• messages (78-82)
• response (88-99)
• OPENCLAW_URL (29-29)
• OPENCLAW_URL (29-29)
• OPENCLAW_TOKEN (30-30)
• OPENCLAW_TOKEN (30-30)

src/logger.js (2)

• warn (225-227)
• info (218-220)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Cursor Bugbot

🔇 Additional comments (6)

src/modules/chimeIn.js (6)

1-14: Clean module documentation and imports.

The module header clearly explains the feature's behavior, and imports are minimal and correctly sourced.

---

31-48: Eviction logic looks solid.

Two-phase eviction (time-based, then LRU overflow) is a clean approach. One subtlety: evicted entries with a non-null abortController won't have their in-flight fetches aborted. In practice this is a non-issue because getBuffer refreshes lastActive on every access, so channels mid-evaluation won't be inactive. Worth a brief note if this assumption ever changes.

---

81-135: Evaluation function is well-structured.

Signal composition via AbortSignal.any, structured <conversation> delimiters, system-first message ordering, and safe fallback to false on any error — all previous feedback has been addressed cleanly.

---

162-174: Thrown errors from generateChimeInResponse propagate correctly to the caller's catch block.

The asymmetry with shouldChimeIn (which swallows errors and returns false) is intentional and correct: accumulate's try/catch handles the thrown error, resets the counter, and cleans up evaluatingChannels in finally.

---

193-297: accumulate control flow is well-orchestrated.

The concurrency guard, abort-signal threading, post-evaluation cancellation checks, and cleanup in finally are all correct. Previous feedback (unused params, redundant Promise.race, brittle error checks, empty-message guard) has been addressed. The counter-reset semantics on both YES/NO/error paths are consistent.

---

305-316: resetCounter correctly cancels in-flight evaluations.

Aborting the controller and nulling it prevents double-responses when the bot is @mentioned during an active chime-in evaluation cycle.

_{✏️ Tip: You can disable this entire section by setting review_details to false in your review settings.}

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{Bugbot Autofix is ON. A Cloud Agent has been kicked off to fix the reported issue.}

[cursor]

Bugbot Autofix prepared fixes for 1 of the 1 bugs found in the latest run.

• ✅ Fixed: Duplicated message-splitting logic across two modules
  • Created a shared splitMessage utility in src/utils/splitMessage.js with word-boundary-aware splitting and updated both chimeIn.js and events.js to use it, ensuring consistent behavior.

Or push these changes by commenting:

@cursor push 406062b9c3