… strip, read receipts

Fixes 6 critical bugs in the iMessage platform adapter:

1. FLOODING / 150+ DUPLICATE DISPATCHES
   Root cause: timestamp-only deduplication re-dispatched inbound messages
   after every outgoing reply because AppleScript updates last_message_at for
   the chat, causing the next poll to fetch history and re-evaluate messages
   whose timestamps predated the updated watermark.
   Fix: track seen message rowids per chat (_seen_message_ids dict). Only
   dispatch messages whose rowid has not been seen before. Pre-populate rowids
   at startup so historical messages are never dispatched after a restart.
   Cap set to 200 entries per chat to bound memory usage.

2. CONCURRENT POLL OVERLAPS
   Root cause: 10s poll interval vs 15-60s agent response time means 2-6
   concurrent polls fire while a chat is being processed, multiplying
   duplicates from bug NousResearch#1.
   Fix: per-chat asyncio.Lock (_chat_locks dict). _check_new_messages skips
   any chat whose lock is currently held. Lock is held for the duration of
   all dispatches for that chat.

3. DUPLICATE RESPONSES
   Root cause: multiple dispatches of the same message (bugs NousResearch#1+NousResearch#2) each
   independently triggered the agent and sent a reply.
   Fix: resolved by NousResearch#1 and NousResearch#2. Additionally, a recent-dispatch cache
   (_recent_dispatches dict) drops any (chat_rowid, text_hash) combination
   seen within the last 60 seconds as a last-resort safety net.

4. STREAMING CURSOR WHITE BLOCK IN IMESSAGE
   Root cause: GatewayStreamConsumer appends a cursor character (" ▉") to
   intermediate streaming updates and calls adapter.send(). iMessage has no
   edit-message API so the first partial-text send lands as a permanent
   message in the conversation, showing as a white/black block.
   Fix: IMessageAdapter.send() detects content ending with any known cursor
   character and returns SendResult(success=True) immediately (no message_id).
   The stream consumer interprets the missing message_id as a failed initial
   send, disables its streaming session, and lets the normal final-response
   path deliver the complete answer as one clean message.

5. NO READ RECEIPTS
   Fix: on_processing_start hook fires an AppleScript "mark targetChat as
   read" command (fire-and-forget) when message processing begins.

6. POLL INTERVAL TOO AGGRESSIVE
   Fix: DEFAULT_POLL_INTERVAL raised from 10.0 to 30.0 seconds.

7. HARDCODED FDA WARNING PATH
   Fix: removed hardcoded /Users/clawdolf path from the Full Disk Access
   warning log; replaced with a generic instruction.

imsg watch --since-rowid --json works correctly with FDA granted.
Replaces 30-second poll latency with near-instant message delivery.
Watch tasks restart automatically on unexpected exit.
All dedup mechanisms retained as safety nets.

…unrelated gateway changes; document registry bypass

Critical: write_memory was added to delegate_task() but never forwarded
from the two hardcoded dispatch branches in run_agent.py (_invoke_tool
and _execute_tool_calls_sequential). Both branches call delegate_task()
directly, bypassing the registry handler that correctly passes
write_memory. The result: write_memory=True from the model was silently
ignored and the entire feature was a no-op.

Also:
- Reverted unrelated iMessage gateway additions (gateway/config.py,
  gateway/run.py) that were accidentally bundled into this PR
- Added explanatory comment in subagent_memory_tool.py documenting why
  this tool intentionally does not use registry.register()
- Added TestRunAgentDispatchForwardsWriteMemory test class to cover the
  _invoke_tool dispatch path — this test would have caught the bug

…g newline

Root cause: stream consumer sends final accumulated text without cursor as
a new "first message" when no message_id was established. Our send()
suppressed cursor sends but returned no message_id, so stream consumer
never tracked a session, and the final cursor-free send went through as a
real message. Then the normal response path also fired — two identical sends.

Fix:
- send() now returns a fake message_id on cursor suppression so stream
  consumer establishes a session (already_sent=True)
- edit_message() implemented: suppresses cursor edits, delivers only the
  final cursor-free edit as the one real AppleScript send
- Dedup via stream consumer built-in last_sent_text check handles the
  double final-edit call at got_done
- strip leading newlines in both send() and edit_message() to kill the
  blank line at top of first message

…sage

iMessage cannot edit messages so streaming is wrong by design.
Replace complex edit_message workaround with simple stream suppression:
- Track chats mid-stream in _stream_chats set
- Suppress cursor sends (mark in-stream)
- Suppress final got_done stream send (clear state)
- Normal response path delivers one complete message unobstructed
No duplicates, no blank lines, no streaming artifacts.

Replace full-suppression with delta streaming:
- Each stream consumer flush sends only NEW content since last send
- Cursor stripped, delta extracted, delivered as separate iMessage bubble
- User sees response arriving progressively in real time
- Fake message_id on first streaming send -> already_sent=True -> normal
  path skips, no duplicate final send
- edit_message() delegates to send() for same delta behavior
- _last_sent_content tracks per-chat what was last sent

imsg typing/react both require session-scoped access unavailable from
launchd. Typing indicator left as no-op pending alternative approach.

- imsg watch for instant message pickup (no 30s poll delay)
- Delta streaming: each flush sends only new content as separate bubble
- edit_message() delegates to send() for same delta behavior
- _stream_chats + _last_sent_content track streaming state per chat
- _send_chunk intact for AppleScript delivery
- No duplicate sends: fake message_id -> already_sent=True -> normal path skips

Remove delta streaming -- stream consumer flushes at timed intervals
not sentence boundaries, producing awkward mid-sentence splits.
Response is fast enough that intermediate bubbles add no value.
Simple suppression: cursor sends and got_done sends are swallowed,
normal response path delivers one complete clean message.