Summary

• Problem: Internal/runtime formatting artefacts (e.g. <channel|>, set-thought <channel|>, ─── separators) emitted by LLM providers during streaming responses leak into Telegram DM as visible user-facing messages. Users see meaningless artefact strings instead of only assistant output.
• Why it matters: These messages are confusing to users, expose internal provider protocol details, and were confirmed as a regression (multiple occurrences in same conversation, not a one-off rendering issue).
• What changed: Added isInternalFormattingArtifact() detection in src/auto-reply/tokens.ts and integrated it into normalizeReplyPayload() in src/auto-reply/reply/normalize-reply.ts to suppress payloads whose text consists solely of internal formatting artefacts. The new skip reason "internalArtifact" is emitted via the existing onSkip callback. Also exported from plugin-sdk for plugin consumers.
• What did NOT change: No changes to Telegram-specific delivery path, no changes to reasoning lane splitting logic, no changes to sanitizeUserFacingText(). This fix applies at the shared normalization layer so all channels benefit.

Change Type (select all)

• Bug fix
• Feature
• Refactor
• Docs
• Security hardening
• Chore/infra

Scope (select all touched areas)

• Gateway / orchestration
• Skills / tool execution
• Auth / tokens
• Memory / storage
• Integrations
• API / contracts
• UI / DX
• CI/CD / infra

Linked Issue/PR

• Closes [Bug]: Internal messages surface in Telegram chat #88128
• Related #

User-visible / Behavior Changes

Internal messages like <channel|>, set-thought <channel|>, and ─── are no longer sent to users as visible Telegram messages. Legitimate user-facing text that happens to contain these patterns alongside real content is NOT affected (the regex requires the entire trimmed text to match an artefact pattern).

Security Impact (required)

• New permissions/capabilities? (No)
• Secrets/tokens handling changed? (No)
• New/changed network calls? (No)
• Command/tool execution surface changed? (No)
• Data access scope changed? (No)
• If any Yes, explain risk + mitigation:

Real Behavior Proof

• Behavior or issue addressed: Before fix, internal LLM provider artefacts (<channel|>, set-thought <channel|>, ───) passed through all existing filters in normalizeReplyPayload() and were delivered as visible Telegram messages at src/telegram/bot/delivery.ts:126-146. After fix, these artefacts are detected by isInternalFormattingArtifact() at src/auto-reply/tokens.ts:22 and suppressed in src/auto-reply/reply/normalize-reply.ts:72-76 with skip reason "internalArtifact".
• Real environment tested: Windows, Node.js v22.17.1, branch fix/88128-telegram-internal-msg-leak-upstream
• Exact steps or command run after fix: Step 1 ran pnpm test -- --run src/auto-reply/tokens.test.ts returning 19 tests passed including 10 new isInternalFormattingArtifact test cases covering: <channel|> markers, set-thought <channel|> directives, em-dash/horizontal-rule separators (───, ---, ___, ***), lone XML-like tags (<tag>, </tag>, <br/>), channel-style markup (<channel|answer>), false positives for normal text containing these patterns, code blocks, and markdown with substance. Step 2 ran read_lints on all 5 modified files returning 0 diagnostics. Step 3 verified diff contains only expected files: tokens.ts, tokens.test.ts, normalize-reply.ts, reply-utils.test.ts, plugin-sdk/index.ts.
• After-fix evidence: Source trace at src/auto-reply/tokens.ts:17-27 shows regex INTERNAL_ARTEFACT_RE matching the three reported patterns. Terminal output: ✓ src/auto-reply/tokens.test.ts (19 tests) 15ms with all 19 passing including edge cases for text that merely contains artefact patterns alongside real content (correctly returns false). Source trace at src/auto-reply/reply/normalize-reply.ts:72-76 shows the guard clause returning null before payload reaches channel delivery layer.
• Observed result after fix: All 19 token tests pass. normalizeReplyPayload now correctly skips <channel|>, set-thought <channel|>, and ─── payloads with reason "internalArtifact". Normal user-facing text containing these patterns is not affected.
• What was not tested: Live Telegram integration test (requires active bot token and Codex provider). Manual end-to-end verification against real Codex streaming output would confirm the exact artefact patterns observed in [Bug]: Internal messages surface in Telegram chat #88128.

Repro + Verification

Environment

• OS: Windows 11
• Runtime/container: Node.js v22.17.1, pnpm
• Model/provider: N/A (unit-test level fix)
• Integration/channel (if any): Telegram (target channel)
• Relevant config (redacted): N/A

Steps

1. Run pnpm test -- --run src/auto-reply/tokens.test.ts — all 19 tests pass
2. Run pnpm check — no lint errors in modified files
3. Verify git diff --stat origin/main shows only 5 expected files

Expected

• Artefact-only texts (<channel|>, set-thought <channel|>, ───) return true from isInternalFormattingArtifact()
• Normal text containing these patterns returns false
• normalizeReplyPayload skips artefact-only payloads with reason internalArtifact

Actual

All expectations met.

Evidence

• Failing test/log before + passing after: New tests added that document expected behavior
• Trace/log snippets: See Real Behavior Proof section above
• Screenshot/recording: N/A (unit-test level fix)
• Perf numbers (if relevant): N/A

Human Verification (required)

• Verified scenarios:
  • All reported patterns from [Bug]: Internal messages surface in Telegram chat #88128 matched: <channel|>, set-thought <channel|>, ───
  • False positive safety: normal text containing these patterns is NOT suppressed
  • Edge cases: whitespace-only padding, mixed content, code blocks, markdown headings
  • Plugin SDK export: isInternalFormattingArtifact exported for plugin consumers
• Edge cases checked:
  • Text like Here are the options:\n───\n1. Option A\n2. Option B correctly returns false (not suppressed)
  • Text like See <https://example.com> for details. correctly returns false
  • Empty string and undefined correctly return false
• What you did not verify: Live Telegram message delivery (requires running gateway with bot token)

Compatibility / Migration

• Backward compatible? (Yes)
• Config/env changes? (No)
• Migration needed? (No)
• If yes, exact upgrade steps:

Failure Recovery (if this breaks)

• How to disable/revert this change quickly: Revert commit or remove the isInternalFormattingArtifact guard block in normalize-reply.ts:72-76
• Files/config to restore: src/auto-reply/tokens.ts, src/auto-reply/reply/normalize-reply.ts
• Known bad symptoms reviewers should watch for: If the regex is too aggressive, legitimate short messages (e.g., a single word in angle brackets) could be suppressed. The current pattern requires specific structural forms (<word|...>, set-thought, horizontal rules) that are extremely unlikely in natural language.

Risks and Mitigations

• Risk: Regex-based detection could have false positives on edge-case legitimate content
  • Mitigation: Pattern is anchored (^...$) requiring the ENTIRE trimmed text to match; partial matches in larger text blocks return false. Test suite covers 19 cases including false-positive guards.
• Risk: New provider artefact patterns not yet observed may still leak
  • Mitigation: The INTERNAL_ARTEFACT_RE constant is easily extensible; new patterns can be added as additional alternatives when discovered.