fix(cmail): install cmail-action on PATH instead of per-project copies

protocols.org said cmail-action was symlinked into ~/.local/bin and on PATH from any project. It wasn't on any machine. The only copies were the per-project .ai/scripts/cmail-action.py the template sync delivers, so the documented invocation died with command not found.

The claim wasn't aspirational. A provisioning script used to create that symlink from ~/projects/claude-templates/, and that path went away when claude-templates became a subtree here. The doc outlived its mechanism.

The script has no project coupling (every path in it is under $HOME against a hardcoded bridge address). I moved it to claude-templates/bin/, which make install already links. The documented command is now true, and 17 copies collapse to one.

Its test moved to scripts/tests/ and needed an explicit SourceFileLoader, because dropping the .py suffix stops importlib inferring one from the extension. The test target gained a pytest pass over scripts/tests. Without it the move would have dropped 57 tests while still reporting green.

triage-intake's cmail gate now tests command -v cmail-action rather than a file path, so it checks what it runs. protocols.org names the repair when the command is missing, and names Proton Bridge as a precondition.

5 files changed, 10 insertions, 728 deletions

diff --git a/claude-templates/.ai/protocols.org b/claude-templates/.ai/protocols.org
index bf0e6f7..0a226a9 100644
--- a/claude-templates/.ai/protocols.org
+++ b/claude-templates/.ai/protocols.org
@@ -344,7 +344,7 @@ Craig has three mail accounts. *Default to cmail for personal / non-work email*
 | =gmail= | =craigmartinjennings@gmail.com=      | Third account, rarely the right one. |
 |---------+--------------------------------------+--------------------------------------|
 
-*The tool is =cmail-action send=* (symlinked into =~/.local/bin=, on PATH from any project). Don't hand-roll MIME or pipe raw messages through =msmtp= — the script builds the message, threading, and attachments for you.
+*The tool is =cmail-action send=*, on PATH from any project. =make install= symlinks it into =~/.local/bin= from =claude-templates/bin/=, and startup runs that install every session — so if =command -v cmail-action= comes back empty, the machine needs a rulesets pull plus =make install=, not a hunt for the script. Don't hand-roll MIME or pipe raw messages through =msmtp= — the script builds the message, threading, and attachments for you.
 
 #+begin_src bash
 # simple
@@ -360,6 +360,8 @@ cmail-action send --to addr@example.com --subject "Re: ..." --body-file /tmp/dra
 
 =cmail-action= handles the receive/triage side too (=list-unread=, =read=, =mark-read=, =star=, =trash=). For the full guided flow (validate the recipient against =contacts.org=, confirm before sending, verify delivery), run the =send-email= workflow; for a known recipient, the one-liner above is enough.
 
+*cmail needs Proton Bridge up.* Every =cmail-action= subcommand talks to the local Bridge (IMAP =127.0.0.1:1143=, SMTP =127.0.0.1:1025=), so nothing works when Bridge is down — start it with =systemctl --user start protonmail-bridge=. The script fails loudly rather than mysteriously: both the IMAP and SMTP paths exit naming Bridge and the =systemctl= command to check it, so read the error before assuming a network or credential problem. The other two accounts don't route through Bridge and are unaffected.
+
 ** Task List Location
 Craig's global task list is available at: =/home/cjennings/org/roam/inbox.org=
 
diff --git a/claude-templates/.ai/scripts/tests/test_cmail_action.py b/claude-templates/.ai/scripts/tests/test_cmail_action.py
deleted file mode 100644
index 6788464..0000000
--- a/claude-templates/.ai/scripts/tests/test_cmail_action.py
+++ /dev/null
@@ -1,720 +0,0 @@
-"""Tests for cmail-action.py.
-
-Covers:
-- Pure helpers: parse_fetch_metadata, extract_body, _decode_header
-- I/O commands: cmd_list_unread, cmd_read, cmd_trash, _store wrappers,
-  cmd_folders
-- Argparse dispatch (subprocess --help)
-
-Strategy: import the script via importlib.util (filename has a hyphen,
-so a regular `import cmail_action` won't work). Patch
-cmail_action.connect to return a configured MagicMock IMAP4 instance
-for the I/O tests. connect() itself is testability-blocked (network +
-SSL + file I/O); manual smoke testing covers it.
-"""
-
-from __future__ import annotations
-
-import email
-import importlib.util
-import json
-import subprocess
-import sys
-from email.message import EmailMessage
-from email.mime.application import MIMEApplication
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-from email.policy import default as default_policy
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-SCRIPT_PATH = Path(__file__).resolve().parent.parent / "cmail-action.py"
-
-
-def _load_module():
-    spec = importlib.util.spec_from_file_location("cmail_action", str(SCRIPT_PATH))
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture(scope="module")
-def cmail_action():
-    return _load_module()
-
-
-# ---------------------------------------------------------------------------
-# parse_fetch_metadata — pure
-# ---------------------------------------------------------------------------
-
-class TestParseFetchMetadata:
-
-    def test_normal_flags_and_size(self, cmail_action):
-        meta = "1 (FLAGS (\\Seen) RFC822.SIZE 12345)"
-        assert cmail_action.parse_fetch_metadata(meta) == {
-            "flags": "\\Seen",
-            "size": 12345,
-        }
-
-    def test_boundary_empty_flags_zero_size(self, cmail_action):
-        meta = "1 (FLAGS () RFC822.SIZE 0)"
-        assert cmail_action.parse_fetch_metadata(meta) == {
-            "flags": "",
-            "size": 0,
-        }
-
-    def test_boundary_multiple_flags(self, cmail_action):
-        meta = "1 (FLAGS (\\Seen \\Flagged \\Recent) RFC822.SIZE 999)"
-        result = cmail_action.parse_fetch_metadata(meta)
-        assert result["flags"] == "\\Seen \\Flagged \\Recent"
-        assert result["size"] == 999
-
-    def test_boundary_no_size_key(self, cmail_action):
-        meta = "1 (FLAGS (\\Recent))"
-        result = cmail_action.parse_fetch_metadata(meta)
-        assert result["flags"] == "\\Recent"
-        assert result["size"] is None
-
-    def test_boundary_no_flags_key(self, cmail_action):
-        meta = "1 (RFC822.SIZE 500)"
-        result = cmail_action.parse_fetch_metadata(meta)
-        assert result["flags"] == ""
-        assert result["size"] == 500
-
-    def test_boundary_metadata_split_across_chunks_concatenated(self, cmail_action):
-        # The bug fix that motivated extracting this helper: imaplib returns
-        # FLAGS / RFC822.SIZE in a non-tuple chunk after the BODY literal
-        # closes. cmd_list_unread now concatenates all chunks, then
-        # parse_fetch_metadata sees the combined string. Verify the parser
-        # handles the combined shape.
-        combined = ("3315 (BODY[HEADER.FIELDS (FROM TO)] {123}"
-                    "  FLAGS () RFC822.SIZE 65546)")
-        result = cmail_action.parse_fetch_metadata(combined)
-        assert result["flags"] == ""
-        assert result["size"] == 65546
-
-    def test_error_empty_input(self, cmail_action):
-        assert cmail_action.parse_fetch_metadata("") == {"flags": "", "size": None}
-
-    def test_error_malformed_size_value_does_not_raise(self, cmail_action):
-        meta = "1 (RFC822.SIZE notanumber)"
-        result = cmail_action.parse_fetch_metadata(meta)
-        assert result["size"] is None
-
-    def test_error_unclosed_flags_paren_returns_empty_flags(self, cmail_action):
-        # Defensive: parser doesn't find a closing paren after FLAGS (, so
-        # flags stays empty. Size still parses since RFC822.SIZE is found
-        # via the independent token-scan path.
-        meta = "1 (FLAGS (\\Seen RFC822.SIZE 100"
-        result = cmail_action.parse_fetch_metadata(meta)
-        assert result["flags"] == ""
-        assert result["size"] == 100
-
-
-# ---------------------------------------------------------------------------
-# extract_body — pure
-# ---------------------------------------------------------------------------
-
-class TestExtractBody:
-
-    @staticmethod
-    def _multipart_alt(plain="plain text body", html="<p>html body</p>"):
-        # Build with the legacy MIME* constructors, then round-trip
-        # through email.message_from_bytes with the default policy so the
-        # parts are EmailMessage instances with .get_content() — matching
-        # what cmd_read sees when imaplib hands it RFC822 bytes.
-        msg = MIMEMultipart("alternative")
-        if plain is not None:
-            msg.attach(MIMEText(plain, "plain"))
-        if html is not None:
-            msg.attach(MIMEText(html, "html"))
-        return email.message_from_bytes(msg.as_bytes(), policy=default_policy)
-
-    def test_normal_multipart_prefers_text_plain(self, cmail_action):
-        msg = self._multipart_alt(plain="plain wins", html="<p>html loses</p>")
-        assert cmail_action.extract_body(msg) == "plain wins"
-
-    def test_boundary_html_only_multipart_falls_back_to_html(self, cmail_action):
-        msg = self._multipart_alt(plain=None, html="<p>only html</p>")
-        result = cmail_action.extract_body(msg)
-        assert result is not None
-        assert "only html" in result
-
-    def test_boundary_singlepart_returns_content_directly(self, cmail_action):
-        msg = EmailMessage()
-        msg.set_content("single-part body")
-        # set_content adds Content-Type: text/plain by default; result has
-        # a trailing newline from the policy formatter.
-        assert cmail_action.extract_body(msg).strip() == "single-part body"
-
-    def test_error_multipart_with_no_text_parts_returns_none(self, cmail_action):
-        msg = MIMEMultipart("alternative")
-        msg.attach(MIMEApplication(b"binary blob"))
-        # Round-trip for parity with the parser-based path real callers use.
-        parsed = email.message_from_bytes(msg.as_bytes(), policy=default_policy)
-        assert cmail_action.extract_body(parsed) is None
-
-
-# ---------------------------------------------------------------------------
-# _decode_header — pure
-# ---------------------------------------------------------------------------
-
-class TestDecodeHeader:
-
-    def test_normal_string(self, cmail_action):
-        assert cmail_action._decode_header("hello") == "hello"
-
-    def test_boundary_empty_string(self, cmail_action):
-        assert cmail_action._decode_header("") == ""
-
-    def test_boundary_none_returns_empty(self, cmail_action):
-        assert cmail_action._decode_header(None) == ""
-
-    def test_boundary_non_string_coerced_via_str(self, cmail_action):
-        assert cmail_action._decode_header(42) == "42"
-
-
-# ---------------------------------------------------------------------------
-# Helpers for I/O command tests
-# ---------------------------------------------------------------------------
-
-def _build_fetch_response(uid, from_addr="alice@example.com", subject="Hello",
-                         size=1500):
-    """Mimic imaplib's FETCH response shape: BODY literal as a tuple,
-    trailing FLAGS/SIZE/close-paren as a separate bytes chunk.
-    """
-    headers = (
-        f"From: {from_addr}\r\n"
-        f"To: c@cjennings.net\r\n"
-        f"Subject: {subject}\r\n"
-        f"Date: Thu, 07 May 2026 12:00:00 -0500\r\n"
-    ).encode()
-    return ("OK", [
-        (f"{uid} (BODY[HEADER.FIELDS (FROM TO SUBJECT DATE)] "
-         f"{{{len(headers)}}}".encode(), headers),
-        f" FLAGS () RFC822.SIZE {size})".encode(),
-    ])
-
-
-# ---------------------------------------------------------------------------
-# cmd_list_unread — mocked imaplib
-# ---------------------------------------------------------------------------
-
-class TestCmdListUnread:
-
-    def test_normal_three_unread(self, cmail_action, capsys):
-        fetch_responses = {
-            b"100": _build_fetch_response("100", "alice@example.com", "Hello", 1500),
-            b"101": _build_fetch_response("101", "bob@example.com", "Howdy", 2000),
-            b"102": _build_fetch_response("102", "carol@example.com", "Hi", 500),
-        }
-
-        def uid_side_effect(cmd, *args):
-            if cmd == "SEARCH":
-                return ("OK", [b"100 101 102"])
-            if cmd == "FETCH":
-                return fetch_responses[args[0]]
-            return ("OK", [b""])
-
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = uid_side_effect
-
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_list_unread(SimpleNamespace(limit=50))
-
-        parsed = json.loads(capsys.readouterr().out)
-        assert len(parsed) == 3
-        assert parsed[0]["uid"] == "100"
-        assert parsed[0]["from"] == "alice@example.com"
-        assert parsed[0]["subject"] == "Hello"
-        assert parsed[0]["size"] == 1500
-        assert parsed[2]["uid"] == "102"
-
-    def test_boundary_zero_unread(self, cmail_action, capsys):
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = lambda cmd, *a: ("OK", [b""])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_list_unread(SimpleNamespace(limit=50))
-        assert json.loads(capsys.readouterr().out) == []
-
-    def test_boundary_single_unread(self, cmail_action, capsys):
-        def uid_se(cmd, *args):
-            if cmd == "SEARCH":
-                return ("OK", [b"42"])
-            if cmd == "FETCH":
-                return _build_fetch_response("42", "x@y", "Solo", 100)
-            return ("OK", [b""])
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = uid_se
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_list_unread(SimpleNamespace(limit=50))
-        parsed = json.loads(capsys.readouterr().out)
-        assert len(parsed) == 1
-        assert parsed[0]["uid"] == "42"
-
-    def test_boundary_limit_truncates_to_most_recent(self, cmail_action, capsys):
-        # 10 unread, limit=3 — keeps the last 3 (most recent).
-        all_uids = [str(i).encode() for i in range(100, 110)]
-
-        def uid_se(cmd, *args):
-            if cmd == "SEARCH":
-                return ("OK", [b" ".join(all_uids)])
-            if cmd == "FETCH":
-                return _build_fetch_response(args[0].decode(), "x@y", "S", 100)
-            return ("OK", [b""])
-
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = uid_se
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_list_unread(SimpleNamespace(limit=3))
-        parsed = json.loads(capsys.readouterr().out)
-        assert [p["uid"] for p in parsed] == ["107", "108", "109"]
-
-    def test_error_search_returns_no(self, cmail_action):
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.return_value = ("NO", [b"server error"])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            with pytest.raises(SystemExit):
-                cmail_action.cmd_list_unread(SimpleNamespace(limit=50))
-
-
-# ---------------------------------------------------------------------------
-# cmd_read — mocked imaplib
-# ---------------------------------------------------------------------------
-
-class TestCmdRead:
-
-    @staticmethod
-    def _rfc822(body="hello world", subject="Test"):
-        msg = EmailMessage()
-        msg["From"] = "alice@example.com"
-        msg["To"] = "c@cjennings.net"
-        msg["Subject"] = subject
-        msg["Date"] = "Thu, 07 May 2026 12:00:00 -0500"
-        msg.set_content(body)
-        return bytes(msg)
-
-    def test_normal_prints_headers_and_body(self, cmail_action, capsys):
-        raw = self._rfc822(body="body content here", subject="subj")
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.return_value = ("OK", [(b"1 (RFC822 {N}", raw)])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_read(SimpleNamespace(uid=42))
-        out = capsys.readouterr().out
-        assert "From: alice@example.com" in out
-        assert "Subject: subj" in out
-        assert "body content here" in out
-
-    def test_error_uid_not_found(self, cmail_action):
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        # imaplib's shape when the UID has no match: ('OK', [None])
-        mock_imap.uid.return_value = ("OK", [None])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            with pytest.raises(SystemExit):
-                cmail_action.cmd_read(SimpleNamespace(uid=999999))
-
-
-# ---------------------------------------------------------------------------
-# _store wrappers — STORE command shape verification
-# ---------------------------------------------------------------------------
-
-class TestStoreCommands:
-
-    @staticmethod
-    def _capture_calls(cmail_action, cmd_func, uids, store_typ="OK"):
-        calls = []
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-
-        def uid_se(cmd, uid, op, flags):
-            calls.append((cmd, op, flags))
-            return (store_typ, [b""])
-
-        mock_imap.uid.side_effect = uid_se
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmd_func(SimpleNamespace(uids=uids))
-        return calls
-
-    def test_normal_mark_read_uses_plus_seen(self, cmail_action):
-        calls = self._capture_calls(cmail_action, cmail_action.cmd_mark_read, [42])
-        assert calls == [("STORE", "+FLAGS", r"(\Seen)")]
-
-    def test_normal_mark_unread_uses_minus_seen(self, cmail_action):
-        calls = self._capture_calls(cmail_action, cmail_action.cmd_mark_unread, [42])
-        assert calls == [("STORE", "-FLAGS", r"(\Seen)")]
-
-    def test_normal_star_uses_plus_flagged_and_seen(self, cmail_action):
-        calls = self._capture_calls(cmail_action, cmail_action.cmd_star, [42])
-        assert calls == [("STORE", "+FLAGS", r"(\Flagged \Seen)")]
-
-    def test_normal_unstar_uses_minus_flagged(self, cmail_action):
-        calls = self._capture_calls(cmail_action, cmail_action.cmd_unstar, [42])
-        assert calls == [("STORE", "-FLAGS", r"(\Flagged)")]
-
-    def test_boundary_multi_uid_calls_store_per_uid(self, cmail_action):
-        calls = self._capture_calls(
-            cmail_action, cmail_action.cmd_mark_read, [1, 2, 3]
-        )
-        assert len(calls) == 3
-        assert all(c == ("STORE", "+FLAGS", r"(\Seen)") for c in calls)
-
-    def test_error_store_failure_raises_systemexit(self, cmail_action):
-        with pytest.raises(SystemExit):
-            self._capture_calls(
-                cmail_action, cmail_action.cmd_mark_read, [42], store_typ="NO"
-            )
-
-
-# ---------------------------------------------------------------------------
-# cmd_trash — MOVE happy path + COPY+DELETE+EXPUNGE fallback
-# ---------------------------------------------------------------------------
-
-class TestCmdTrash:
-
-    def test_normal_move_succeeds_and_expunges(self, cmail_action):
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.return_value = ("OK", [b""])
-        mock_imap.expunge.return_value = ("OK", [b""])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_trash(SimpleNamespace(uids=[100, 101]))
-        move_calls = [c for c in mock_imap.uid.call_args_list
-                      if c[0][0] == "MOVE"]
-        assert len(move_calls) == 2
-        assert mock_imap.expunge.called
-
-    def test_boundary_move_fails_falls_back_to_copy_then_delete(self, cmail_action):
-        # MOVE returns NO -> fallback path: COPY, then STORE +FLAGS \Deleted,
-        # then EXPUNGE. Verify the sequence executes as documented.
-        seen_cmds = []
-
-        def uid_se(cmd, *args):
-            seen_cmds.append(cmd)
-            if cmd == "MOVE":
-                return ("NO", [b"not supported"])
-            return ("OK", [b""])
-
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = uid_se
-        mock_imap.expunge.return_value = ("OK", [b""])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_trash(SimpleNamespace(uids=[100]))
-        assert seen_cmds == ["MOVE", "COPY", "STORE"]
-        assert mock_imap.expunge.called
-
-    def test_error_copy_also_fails(self, cmail_action):
-        mock_imap = MagicMock()
-        mock_imap.select.return_value = ("OK", [b""])
-        mock_imap.uid.side_effect = lambda cmd, *a: ("NO", [b"both fail"])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            with pytest.raises(SystemExit):
-                cmail_action.cmd_trash(SimpleNamespace(uids=[100]))
-
-
-# ---------------------------------------------------------------------------
-# cmd_folders
-# ---------------------------------------------------------------------------
-
-class TestCmdFolders:
-
-    def test_normal_lists_folders(self, cmail_action, capsys):
-        mock_imap = MagicMock()
-        mock_imap.list.return_value = ("OK", [
-            b'(\\HasNoChildren) "/" "INBOX"',
-            b'(\\HasNoChildren \\Trash) "/" "Trash"',
-        ])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            cmail_action.cmd_folders(SimpleNamespace())
-        out = capsys.readouterr().out
-        assert "INBOX" in out
-        assert "Trash" in out
-
-    def test_error_list_returns_no(self, cmail_action):
-        mock_imap = MagicMock()
-        mock_imap.list.return_value = ("NO", [b"server error"])
-        with patch.object(cmail_action, "connect", return_value=mock_imap):
-            with pytest.raises(SystemExit):
-                cmail_action.cmd_folders(SimpleNamespace())
-
-
-# ---------------------------------------------------------------------------
-# build_message — pure
-# ---------------------------------------------------------------------------
-
-class TestBuildMessage:
-
-    def test_normal_no_attachments_is_singlepart(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="recipient@example.com",
-            subject="Hello",
-            body="hello world",
-        )
-        assert msg["From"] == "c@cjennings.net"
-        assert msg["To"] == "recipient@example.com"
-        assert msg["Subject"] == "Hello"
-        assert not msg.is_multipart()
-        assert msg.get_content().strip() == "hello world"
-        assert msg.get_content_type() == "text/plain"
-
-    def test_normal_one_attachment_makes_multipart(self, cmail_action):
-        attachment = ("report.txt", "text", "plain", b"line1\nline2\n")
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="recipient@example.com",
-            subject="With file",
-            body="see attached",
-            attachments=[attachment],
-        )
-        assert msg.is_multipart()
-        # Find the attachment part by Content-Disposition.
-        attached_parts = [
-            p for p in msg.iter_attachments()
-            if p.get_filename() == "report.txt"
-        ]
-        assert len(attached_parts) == 1
-        att = attached_parts[0]
-        assert att.get_content_type() == "text/plain"
-        assert att.get_content().rstrip("\n") == "line1\nline2"
-
-    def test_boundary_two_attachments(self, cmail_action):
-        atts = [
-            ("a.txt", "text", "plain", b"alpha"),
-            ("b.bin", "application", "octet-stream", b"\x00\x01\x02"),
-        ]
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="recipient@example.com",
-            subject="Two files",
-            body="see attached",
-            attachments=atts,
-        )
-        names = sorted(p.get_filename() for p in msg.iter_attachments())
-        assert names == ["a.txt", "b.bin"]
-
-    def test_boundary_empty_body(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="recipient@example.com",
-            subject="Empty",
-            body="",
-        )
-        # Body part exists, content is empty (modulo trailing newline).
-        assert msg.get_content().strip() == ""
-
-    def test_boundary_unicode_preserved_through_serialization(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="recipient@example.com",
-            subject="日本語 ñ ü",
-            body="café — naïve résumé",
-        )
-        # Round-trip: serialize, parse, check both Subject and body survived.
-        raw = msg.as_bytes()
-        parsed = email.message_from_bytes(raw, policy=default_policy)
-        assert parsed["Subject"] == "日本語 ñ ü"
-        assert "café" in parsed.get_content()
-
-    def test_cc_and_bcc_headers_set_from_lists(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="to@example.com",
-            subject="Re: thread",
-            body="body",
-            cc=["cc1@example.com", "cc2@example.com"],
-            bcc=["bcc@example.com"],
-        )
-        assert msg["Cc"] == "cc1@example.com, cc2@example.com"
-        assert msg["Bcc"] == "bcc@example.com"
-
-    def test_threading_headers_set(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="to@example.com",
-            subject="Re: thread",
-            body="body",
-            in_reply_to="<abc@host>",
-            references="<root@host> <abc@host>",
-        )
-        assert msg["In-Reply-To"] == "<abc@host>"
-        assert msg["References"] == "<root@host> <abc@host>"
-
-    def test_no_cc_bcc_or_threading_headers_when_omitted(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="to@example.com",
-            subject="plain",
-            body="body",
-        )
-        assert msg["Cc"] is None
-        assert msg["Bcc"] is None
-        assert msg["In-Reply-To"] is None
-        assert msg["References"] is None
-
-    def test_cc_accepts_a_bare_string(self, cmail_action):
-        msg = cmail_action.build_message(
-            from_addr="c@cjennings.net",
-            to_addr="to@example.com",
-            subject="s",
-            body="b",
-            cc="solo@example.com",
-        )
-        assert msg["Cc"] == "solo@example.com"
-
-
-# ---------------------------------------------------------------------------
-# load_attachment — file I/O via tmp_path
-# ---------------------------------------------------------------------------
-
-class TestLoadAttachment:
-
-    def test_normal_text_file(self, cmail_action, tmp_path):
-        p = tmp_path / "notes.txt"
-        p.write_text("hello\n")
-        filename, maintype, subtype, content = cmail_action.load_attachment(p)
-        assert filename == "notes.txt"
-        assert maintype == "text"
-        assert subtype == "plain"
-        assert content == b"hello\n"
-
-    def test_normal_pdf_mime_detected(self, cmail_action, tmp_path):
-        p = tmp_path / "doc.pdf"
-        p.write_bytes(b"%PDF-1.4 fake")
-        filename, maintype, subtype, _ = cmail_action.load_attachment(p)
-        assert filename == "doc.pdf"
-        assert (maintype, subtype) == ("application", "pdf")
-
-    def test_boundary_no_extension_falls_back_to_octet_stream(self, cmail_action, tmp_path):
-        p = tmp_path / "README"
-        p.write_text("readme content")
-        filename, maintype, subtype, _ = cmail_action.load_attachment(p)
-        assert filename == "README"
-        assert (maintype, subtype) == ("application", "octet-stream")
-
-    def test_boundary_empty_file(self, cmail_action, tmp_path):
-        p = tmp_path / "empty.txt"
-        p.write_text("")
-        _, _, _, content = cmail_action.load_attachment(p)
-        assert content == b""
-
-    def test_error_missing_file_raises(self, cmail_action, tmp_path):
-        p = tmp_path / "does-not-exist.txt"
-        with pytest.raises(FileNotFoundError):
-            cmail_action.load_attachment(p)
-
-    def test_error_directory_raises(self, cmail_action, tmp_path):
-        with pytest.raises(IsADirectoryError):
-            cmail_action.load_attachment(tmp_path)
-
-
-# ---------------------------------------------------------------------------
-# cmd_send — mocked smtp_connect
-# ---------------------------------------------------------------------------
-
-class TestCmdSend:
-
-    @staticmethod
-    def _args(to="r@example.com", subject="s", body="b", body_file=None,
-              attach=None, stdin=False, cc=None, bcc=None,
-              in_reply_to=None, references=None):
-        return SimpleNamespace(
-            to=to, subject=subject,
-            body=None if stdin else body,
-            body_file=body_file,
-            attach=attach or [],
-            cc=cc or [],
-            bcc=bcc or [],
-            in_reply_to=in_reply_to,
-            references=references,
-        )
-
-    def test_normal_inline_body_calls_send_message(self, cmail_action):
-        mock_smtp = MagicMock()
-        with patch.object(cmail_action, "smtp_connect", return_value=mock_smtp):
-            cmail_action.cmd_send(self._args(
-                to="recipient@example.com",
-                subject="testing cmail action script",
-                body="lorem ipsum dolor sit amet",
-            ))
-        mock_smtp.send_message.assert_called_once()
-        sent = mock_smtp.send_message.call_args[0][0]
-        assert sent["To"] == "recipient@example.com"
-        assert sent["Subject"] == "testing cmail action script"
-        assert sent["From"] == cmail_action.USER
-        assert "lorem ipsum dolor sit amet" in sent.get_content()
-        mock_smtp.quit.assert_called_once()
-
-    def test_boundary_body_from_file(self, cmail_action, tmp_path):
-        body_file = tmp_path / "body.txt"
-        body_file.write_text("body from file")
-        mock_smtp = MagicMock()
-        with patch.object(cmail_action, "smtp_connect", return_value=mock_smtp):
-            cmail_action.cmd_send(self._args(body=None, body_file=str(body_file)))
-        sent = mock_smtp.send_message.call_args[0][0]
-        assert "body from file" in sent.get_content()
-
-    def test_boundary_with_attachment(self, cmail_action, tmp_path):
-        att = tmp_path / "report.txt"
-        att.write_text("attachment content")
-        mock_smtp = MagicMock()
-        with patch.object(cmail_action, "smtp_connect", return_value=mock_smtp):
-            cmail_action.cmd_send(self._args(attach=[str(att)]))
-        sent = mock_smtp.send_message.call_args[0][0]
-        assert sent.is_multipart()
-        atts = list(sent.iter_attachments())
-        assert len(atts) == 1
-        assert atts[0].get_filename() == "report.txt"
-        assert atts[0].get_content().rstrip("\n") == "attachment content"
-
-    def test_error_missing_attachment_exits_before_smtp(self, cmail_action, tmp_path):
-        # Attachment files are validated first; SMTP is never opened on failure.
-        mock_smtp = MagicMock()
-        with patch.object(cmail_action, "smtp_connect", return_value=mock_smtp):
-            with pytest.raises((SystemExit, FileNotFoundError)):
-                cmail_action.cmd_send(self._args(
-                    attach=[str(tmp_path / "does-not-exist.txt")]
-                ))
-        mock_smtp.send_message.assert_not_called()
-
-    def test_error_smtp_send_failure_raises(self, cmail_action):
-        import smtplib
-        mock_smtp = MagicMock()
-        mock_smtp.send_message.side_effect = smtplib.SMTPException("boom")
-        with patch.object(cmail_action, "smtp_connect", return_value=mock_smtp):
-            with pytest.raises((SystemExit, smtplib.SMTPException)):
-                cmail_action.cmd_send(self._args())
-
-
-# ---------------------------------------------------------------------------
-# Argparse — black-box subprocess sanity check
-# ---------------------------------------------------------------------------
-
-class TestArgparseShape:
-
-    def test_normal_help_lists_all_subcommands(self):
-        result = subprocess.run(
-            [sys.executable, str(SCRIPT_PATH), "--help"],
-            capture_output=True, text=True,
-        )
-        assert result.returncode == 0
-        for sub in ("list-unread", "read", "mark-read", "mark-unread",
-                    "star", "unstar", "trash", "folders", "send"):
-            assert sub in result.stdout
-
-    def test_error_no_subcommand_exits_nonzero(self):
-        result = subprocess.run(
-            [sys.executable, str(SCRIPT_PATH)],
-            capture_output=True, text=True,
-        )
-        assert result.returncode != 0
diff --git a/claude-templates/.ai/workflows/startup.org b/claude-templates/.ai/workflows/startup.org
index bc89256..d52add6 100644
--- a/claude-templates/.ai/workflows/startup.org
+++ b/claude-templates/.ai/workflows/startup.org
@@ -205,7 +205,7 @@ Notes on what =sync-templates= does (the rsync behavior it carries):
 - The =scripts/= sync excludes Python build artifacts (=__pycache__/=, =.pytest_cache/=, =*.pyc=). Running rulesets' own pytest leaves these in =claude-templates/.ai/scripts/tests/=, and =rsync -a= copies by disk presence regardless of =.gitignore=, so without the excludes every consuming project's tree gets polluted with machine-specific cache files. The excludes also protect existing dest copies from =--delete= cleanup, so a project that already received the cache must remove it once by hand.
 - The sync is guarded to skip when rulesets has uncommitted changes under the synced source paths. =rsync -a --delete= copies the working tree by disk presence, so without the guard a downstream session started while rulesets had in-flight WIP would pull that WIP into its =.ai/workflows/= and =.ai/scripts/=, surfacing as drift the user never authored (and tempting a fake "chore: sync .ai tooling" commit). The guard is scoped to the synced paths, not the whole repo, so unrelated rulesets dirt doesn't block the sync. From the jr-estate handoff 2026-05-29.
 - The sync is also guarded to skip when the *project* branch is behind its upstream (=proj_behind=). Phase A.0 correctly declines to fast-forward a diverged or behind-and-dirty branch, but the rsync would then land templates on the stale committed =.ai/= baseline — a huge diff measured against old content that conflicts once the branch reconciles to upstream's newer templates. Skipping is safe: the sync runs next session once the branch is current. Not an auto-discard — startup never =git checkout=s drift away, because a legitimate local stopgap in a synced file is indistinguishable from accidental drift by content alone (home reverted an intentional =flashcard-to-anki.py= fix this way on 2026-06-22). Prevention is safe; blind cleanup-after is not. Phase C's template-sync-churn safety net still surfaces any pre-existing dirt for a human decision. From the home handoff 2026-07-04.
-- The sync touches only =protocols.org=, =workflows/=, and =scripts/=. The project-owned dirs =project-workflows/= and =project-scripts/= are deliberately *outside* the synced set, so a project's own workflows and scripts survive startup. This is why a project script that a workflow imports must live in =.ai/project-scripts/=, never =.ai/scripts/= — the latter is wiped to match the template by =--delete= on every startup. Naming: a script imported as a Python module needs an importable name (underscores, e.g. =zlibrary_api.py=); a CLI-invoked script can stay kebab-case like the template tooling (=cmail-action.py=).
+- The sync touches only =protocols.org=, =workflows/=, and =scripts/=. The project-owned dirs =project-workflows/= and =project-scripts/= are deliberately *outside* the synced set, so a project's own workflows and scripts survive startup. This is why a project script that a workflow imports must live in =.ai/project-scripts/=, never =.ai/scripts/= — the latter is wiped to match the template by =--delete= on every startup. Naming: a script imported as a Python module needs an importable name (underscores, e.g. =zlibrary_api.py=); a CLI-invoked script can stay kebab-case like the template tooling (=inbox-status=).
 
 Rationale: Every call in Phase A is read-only or writes to a distinct path. Running them sequentially wastes round-trips; running them in parallel gives Claude the complete starting picture in one round-trip.
 
diff --git a/claude-templates/.ai/workflows/triage-intake.cmail.org b/claude-templates/.ai/workflows/triage-intake.cmail.org
index 8d8abfb..66ecf80 100644
--- a/claude-templates/.ai/workflows/triage-intake.cmail.org
+++ b/claude-templates/.ai/workflows/triage-intake.cmail.org
@@ -8,7 +8,7 @@
 * Source: cmail
 :PROPERTIES:
 :ORDER:         25
-:ENABLED:       test -f .ai/scripts/cmail-action.py
+:ENABLED:       command -v cmail-action
 :ANCHOR:        none
 :SUBAGENT_OVER: 50
 :END:
@@ -18,7 +18,7 @@
 Proton (=c@cjennings.net=) via the bridge script. =ANCHOR: none= because this reports live IMAP unread *state*, not a since-window — the engine substitutes no cutoff. Phase B uses the anchor only to flag which of the current unread arrived since last check.
 
 #+begin_src bash
-python3 .ai/scripts/cmail-action.py list-unread
+cmail-action list-unread
 #+end_src
 
 JSON output, keyed by UID. The script ignores messages already flagged =\Deleted= (those are pending-flush on the next Proton sync), so the list is the genuinely-live unread set.
@@ -47,7 +47,7 @@ Omit if zero unread.
 
 All take one or more UIDs (from the =list-unread= JSON):
 
-- mark-read :: =python3 .ai/scripts/cmail-action.py mark-read <uid>=
-- star      :: =python3 .ai/scripts/cmail-action.py star <uid>=
-- unstar    :: =python3 .ai/scripts/cmail-action.py unstar <uid>=
-- trash     :: =python3 .ai/scripts/cmail-action.py trash <uid>=  (flags =\Deleted=; flushed on next Proton sync)
+- mark-read :: =cmail-action mark-read <uid>=
+- star      :: =cmail-action star <uid>=
+- unstar    :: =cmail-action unstar <uid>=
+- trash     :: =cmail-action trash <uid>=  (flags =\Deleted=; flushed on next Proton sync)
diff --git a/claude-templates/.ai/scripts/cmail-action.py b/claude-templates/bin/cmail-action
index 0acd82d..0acd82d 100755
--- a/claude-templates/.ai/scripts/cmail-action.py
+++ b/claude-templates/bin/cmail-action