chore: bulk safety commit — 12 unsplit fixes from sessions 1-6 + chat.js fix

This is a SINGLE UNSPLIT commit bundling 12 distinct, independently-
developed fixes for durability only — it exists purely to move this work
off of "uncommitted on disk" (fragile: one `git clean`, forced checkout,
or disk issue away from losing sessions of debugging) and onto
"committed and pushed" as fast as safely possible.

This is explicitly NOT the reviewable 12-way PR split proposed in Phase 2
session 9's Part C. That split still needs to happen in a later session,
working from this commit via:

    git reset --soft <this-commit>~1

which un-does exactly this commit, non-destructively, and restores the
working tree to today's on-disk diff for interactive per-fix staging.

Bundled in this commit:
  1. TOOL_SECTIONS entries for 5 previously-unreachable email tools
     (search_emails, draft_email, draft_email_reply, ai_draft_email_reply,
     download_attachment) — src/agent_loop.py
  2. _KEYWORD_HINTS entries for the same 5 tools — src/tool_index.py
  3. IMAP search rewrite: term-AND matching instead of one literal phrase
     — mcp_servers/email_server.py
  4. agent_email_confirm gate extended to archive_email/delete_email/
     mark_email_read/bulk_email (previously only send_email/reply_to_email
     were gated) — mcp_servers/email_server.py, routes/email_routes.py,
     src/agent_loop.py (TOOL_SECTIONS prose)
  5. Domain-classifier keyword-gate widened from 3 hardcoded names to
     general correspondence-verb patterns — src/agent_loop.py
  6. list_emails MCP schema strictness: additionalProperties:false +
     owner/limit argument declarations — src/tool_schemas.py,
     mcp_servers/email_server.py
  7. list_emails attention-query (unread_only/unresponded_only) max_results
     cap raised 20 -> 200 so busy inboxes aren't silently truncated —
     mcp_servers/email_server.py, src/tool_schemas.py, src/agent_loop.py
  8. FUNCTION_TOOL_SCHEMAS entries for the same 5 tools, fixing native/
     API-mode tool-calling reachability — src/tool_schemas.py
  9. BUILTIN_TOOL_DESCRIPTIONS entries for the same 5 tools, fixing
     semantic-RAG reachability — src/tool_index.py
  10. Stale comment correction in src/tool_security.py (folded in with arcahyadi#8)
  11. _DOMAIN_TOOL_MAP["email"] now derived from the canonical
      tool_security.BUILTIN_EMAIL_TOOLS registry instead of a 5th
      hand-typed, drift-prone list — src/agent_loop.py
  12. chat.js live-stream thinking-boundary fix: gemma4:e4b replies whose
      reasoning arrives as unflagged "Thinking Process:" text could get
      stuck permanently collapsed in the thinking box, never rendering
      the real answer — static/js/chat.js

7 new regression tests included (tests/test_*.py). Full narrative and
per-fix session provenance: NOTES.md.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: bstruong

NOTES.md

@@ -28,7 +28,12 @@ Verified-not-assumed against the live repo/DB/git this session. Full detail live
   Endpoint row (data/app.db): id=a3c5a269, supports_tools=1, is_enabled=1.
 - `OLLAMA_CONTEXT_LENGTH=16384` set (host systemd override; verified). Required — /v1 path sends no
   num_ctx; multi-round compound prompts hit 8–13k tokens and truncate at Ollama's ~4096 default.
-- DEFAULT MODEL = **qwen3:8b** (settings.json; verified resolve_endpoint("default") -> qwen3:8b).
+- DEFAULT MODEL = **gemma4:e4b** (settings.json `default_model`/`research_model`; verified
+  `resolve_endpoint("default")` -> gemma4:e4b). Switched from qwen3:8b (this doc's original default,
+  see MODEL RESULTS below) in Phase 2 session 7, based on a cross-model benchmark (sessions 5-6:
+  92% vs. 69% clean correctness across 13 task-instances, faster, lower VRAM) — see NOTES.md for the
+  full evidence trail. qwen3:8b, llama3.1:8b, and granite4.1:8b (the other benchmark candidates) were
+  removed from Ollama in session 8; only gemma4:e4b remains installed.
 - The four fixes that made native tool-calling work on local models:
   1. supports_tools=1 (data/app.db, not git) — else tools_sent=0. Re-apply via
      scripts/set_ollama_supports_tools.py after any data-volume reset.

SYNC.md

@@ -3709,6 +3709,167 @@ async def cancel_agent_draft(sid: str, owner: str = Depends(require_owner)):
             logger.error(f"cancel_agent_draft {sid!r} failed: {e}")
             return {"success": False, "error": "Mail operation failed"}
 
+    # ── Agent mutating-action confirm: list/approve/cancel ───────────────
+    # Same principle as the send-confirm block above, extended to the four
+    # non-send email tools that used to execute immediately against real
+    # IMAP with no confirmation gate: archive_email, delete_email,
+    # mark_email_read, bulk_email. When `agent_email_confirm` is on, the MCP
+    # email server (mcp_servers/email_server.py::_stash_pending_email_action)
+    # stages the request in pending_email_actions instead of touching IMAP.
+    # These endpoints run in the main app process (a separate process from
+    # the MCP server) and perform the actual mutation using the same IMAP
+    # helpers the human Archive/Delete/Mark-read buttons already use — the
+    # MCP server process never executes a gated action itself.
+    @router.get("/pending-actions")
+    async def list_pending_email_actions(owner: str = Depends(require_owner)):
+        import sqlite3
+        try:
+            conn = sqlite3.connect(SCHEDULED_DB)
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                """SELECT id, action, uid, uids, folder, permanent, read_flag,
+                          bulk_action, all_unread, description, account_id, created_at
+                   FROM pending_email_actions
+                   WHERE status = 'agent_pending' AND owner = ?
+                   ORDER BY created_at DESC""",
+                (owner or "",),
+            ).fetchall()
+            conn.close()
+            return {"pending": [dict(r) for r in rows]}
+        except Exception as e:
+            logger.error(f"list_pending_email_actions failed: {e}")
+            return {"pending": [], "error": "Mail operation failed"}
+
+    def _execute_pending_email_action(row: dict, owner: str) -> dict:
+        """Perform the real IMAP mutation for an approved pending action."""
+        action = row["action"]
+        folder = row["folder"] or "INBOX"
+        account_id = row["account_id"]
+        try:
+            if action == "archive":
+                with _imap(account_id, owner=owner) as conn:
+                    conn.select(_q(folder))
+                    if not _move_email_message(conn, row["uid"], "Archive", role="archive"):
+                        return {"success": False, "error": "Email not found"}
+                _email_index_delete(owner, account_id, folder, row["uid"])
+                _invalidate_list_cache(account_id)
+                return {"success": True}
+            if action == "delete":
+                permanent = bool(row["permanent"])
+                with _imap(account_id, owner=owner) as conn:
+                    conn.select(_q(folder))
+                    if permanent:
+                        if not _store_email_flag(conn, row["uid"], "\\Deleted", add=True):
+                            return {"success": False, "error": "Email not found"}
+                        conn.expunge()
+                    else:
+                        if not _move_email_message(conn, row["uid"], "Trash", role="trash"):
+                            return {"success": False, "error": "Email not found"}
+                _email_index_delete(owner, account_id, folder, row["uid"])
+                _invalidate_list_cache(account_id, folder)
+                return {"success": True}
+            if action == "mark_email_read":
+                read = bool(row["read_flag"])
+                with _imap(account_id, owner=owner) as conn:
+                    conn.select(_q(folder))
+                    if not _store_email_flag(conn, row["uid"], "\\Seen", add=read):
+                        return {"success": False, "error": "Email not found"}
+                _email_index_update_flags(owner, account_id, folder, row["uid"], "\\Seen", read)
+                _invalidate_list_cache(account_id)
+                return {"success": True}
+            if action == "bulk_email":
+                bulk_action = row["bulk_action"] or ""
+                permanent = bool(row["permanent"])
+                uids = json.loads(row["uids"]) if row["uids"] else []
+                changed = 0
+                with _imap(account_id, owner=owner) as conn:
+                    conn.select(_q(folder))
+                    if row["all_unread"]:
+                        st, data = conn.uid("SEARCH", None, "UNSEEN")
+                        if st == "OK" and data and data[0]:
+                            uids = [u.decode() if isinstance(u, bytes) else str(u) for u in data[0].split()]
+                    for uid in uids:
+                        ok = False
+                        if bulk_action == "mark_read":
+                            ok = _store_email_flag(conn, uid, "\\Seen", add=True)
+                        elif bulk_action == "mark_unread":
+                            ok = _store_email_flag(conn, uid, "\\Seen", add=False)
+                        elif bulk_action == "archive":
+                            ok = _move_email_message(conn, uid, "Archive", role="archive")
+                        elif bulk_action == "junk":
+                            ok = _move_email_message(conn, uid, "Junk", role="junk")
+                        elif bulk_action == "delete":
+                            if permanent:
+                                ok = _store_email_flag(conn, uid, "\\Deleted", add=True)
+                            else:
+                                ok = _move_email_message(conn, uid, "Trash", role="trash")
+                        if not ok:
+                            continue
+                        changed += 1
+                        if bulk_action in ("archive", "junk", "delete"):
+                            _email_index_delete(owner, account_id, folder, uid)
+                        else:
+                            _email_index_update_flags(owner, account_id, folder, uid, "\\Seen", bulk_action == "mark_read")
+                    if permanent and bulk_action == "delete":
+                        conn.expunge()
+                _invalidate_list_cache(account_id)
+                return {"success": True, "changed": changed, "requested": len(uids)}
+            return {"success": False, "error": f"Unknown pending action type: {action!r}"}
+        except Exception as e:
+            logger.error(f"Failed to execute pending email action {row.get('id')!r} ({action}): {e}")
+            return {"success": False, "error": "Mail operation failed"}
+
+    @router.post("/pending-actions/{aid}/approve")
+    async def approve_email_action(aid: str, owner: str = Depends(require_owner)):
+        import sqlite3
+        try:
+            conn = sqlite3.connect(SCHEDULED_DB)
+            conn.row_factory = sqlite3.Row
+            row = conn.execute(
+                "SELECT * FROM pending_email_actions WHERE id = ? AND status = 'agent_pending' AND owner = ?",
+                (aid, owner or ""),
+            ).fetchone()
+            conn.close()
+            if not row:
+                return {"success": False, "error": "Pending action not found or already handled"}
+            row = dict(row)
+        except Exception as e:
+            logger.error(f"approve_email_action {aid!r} lookup failed: {e}")
+            return {"success": False, "error": "Mail operation failed"}
+        result = _execute_pending_email_action(row, owner or "")
+        try:
+            new_status = "executed" if result.get("success") else "failed"
+            conn = sqlite3.connect(SCHEDULED_DB)
+            conn.execute(
+                "UPDATE pending_email_actions SET status = ?, result = ? WHERE id = ? AND owner = ?",
+                (new_status, json.dumps(result), aid, owner or ""),
+            )
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            logger.error(f"approve_email_action {aid!r} status update failed: {e}")
+        return result
+
+    @router.delete("/pending-actions/{aid}")
+    async def cancel_email_action(aid: str, owner: str = Depends(require_owner)):
+        import sqlite3
+        try:
+            conn = sqlite3.connect(SCHEDULED_DB)
+            cur = conn.execute(
+                """UPDATE pending_email_actions SET status = 'cancelled'
+                   WHERE id = ? AND status = 'agent_pending' AND owner = ?""",
+                (aid, owner or ""),
+            )
+            conn.commit()
+            affected = cur.rowcount
+            conn.close()
+            if not affected:
+                return {"success": False, "error": "Pending action not found or already handled"}
+            return {"success": True}
+        except Exception as e:
+            logger.error(f"cancel_email_action {aid!r} failed: {e}")
+            return {"success": False, "error": "Mail operation failed"}
+
     @router.get("/resolve-contact")
     async def resolve_contact(name: str = Query(..., description="Name to search for"), owner: str = Depends(require_owner)):
         """Search Sent folder for a contact by name. Returns matching email addresses."""