Output is including JSON and tags like "cleaned_text".

[sdotz]

I've seen output from megaphone include blocks of JSON, with keys like clean_text and notes about tool calls. Not sure what is causing this. Happens quite frequently for me using 1.1.8 and seems more (or only) to happen with smart cleanup.

{
  "cleaned_text": "Testing, testing."
}

<cleaned_text>
What's up, my fellow humans?
</cleaned_text>

<cleaned_text>
How do you do, fellow kids?
</cleaned_text>

{
  "text": "- YOLO."
}

[Kuberwastaken]

Confirmed — this is a real bug, and it reproduces at the string-processing layer independent of the model, which is why it's intermittent: the on-device model usually returns bare text, but every so often it wraps its answer in a JSON object or <cleaned_text> tags despite the system prompt saying not to. When it does, nothing peels the wrapper and the scaffolding gets pasted verbatim. (It's more visible on Smart Cleanup because that's the path that runs the model at all.)

Root cause. AppleFoundationModelsPostProcessor.normalizeCommandOutput strips model-invented wrappers from an allowlist (response, result, output, list, …) and has no handling for JSON at all. The wrappers in this issue — cleaned_text / clean_text and JSON objects keyed cleaned_text / text — aren't on that list, so they pass straight through. Running your exact examples through the current pipeline (macOS 26.5.2):

model output	current behavior
<cleaned_text>\n…\n</cleaned_text>	pasted verbatim, tags and all
{"cleaned_text": "Testing, testing."}	pasted verbatim
```json\n{"cleaned_text": "…"}\n```	pasted verbatim (rejected → basic fallback once #15 lands)

Fix. Unwrap these known wrappers in normalizeCommandOutput, before the existing tag loop, so the contained text reaches the user rather than being discarded:

• a single-purpose JSON object — bare or inside a ```json fence — collapses to its text value;
• <cleaned_text> / <clean_text> join the tag allowlist.

Two guards keep genuine dictation safe:

• a JSON object is unwrapped only when every key is a known answer-wrapper key, so real dictated data like {"name": "Ada"} is untouched;
• a code fence is stripped only when it wraps such an object, so a code block you actually dictated (e.g. via a wake command) keeps its fence.

Verified against your samples with the fix in place:

in	out
<cleaned_text>\nWhat's up, my fellow humans?\n</cleaned_text>	What's up, my fellow humans?
{"cleaned_text": "Testing, testing."}	Testing, testing.
```json\n{"text": "- YOLO."}\n```	- YOLO.
{"name": "Ada", "text": "hello"}	(unchanged)
```swift\nprint("hi")\n```	(unchanged)

Because normalizeCommandOutput is the single choke point for every model-output path (dictation cleanup, selection edit, transform, wake command), this covers all of them at once. New unit tests cover the three reported variants plus the must-not-touch cases; full suite passes. PR to follow.

Note #15 (reject-transcript-dropping output) is complementary but doesn't fully solve this — it makes the fenced-JSON variant fall back to basic cleanup, but the bare-JSON and <cleaned_text>-tag variants above still leak until this unwrap lands. With both in, the fenced case unwraps to the smart result and passes validation instead of falling back.