6 files changed, 371 insertions, 15 deletions
diff --git a/claude-templates/.ai/scripts/flashcard-to-anki.py b/claude-templates/.ai/scripts/flashcard-to-anki.py
index 7227683..ca4c70b 100755
--- a/claude-templates/.ai/scripts/flashcard-to-anki.py
+++ b/claude-templates/.ai/scripts/flashcard-to-anki.py
@@ -13,9 +13,11 @@ Parses org-drill structure:
     text (sans :drill: tag). Back = entry body with newlines converted
     to <br>.
 
-Deck name defaults to the input basename, case preserved. Deck and model
-IDs are derived from the deck name via stable hash so re-importing the
-same deck updates existing cards instead of duplicating them.
+Deck name defaults to the org #+TITLE: (so the phone deck reads as the
+curated title), falling back to the input basename when the source has
+no #+TITLE. Deck and model IDs are derived from the deck name via stable
+hash so re-importing the same deck updates existing cards instead of
+duplicating them.
 
 Output defaults to ~/sync/phone/anki/<input-basename>.apkg. The .apkg is
 a mobile-Anki artifact the phone picks up from its sync dir, so it lands
@@ -177,7 +179,19 @@ def build(cards: list[tuple[str, str, str]], deck_name: str) -> genanki.Deck:
     return deck
 
 
-def default_deck_name(input_path: Path) -> str:
+def default_deck_name(input_path: Path, org_text: str) -> str:
+    """Deck name defaults to the org #+TITLE:, falling back to the basename.
+
+    The #+TITLE drives both the org-drill display in Emacs and the Anki
+    deck name on the phone, so the consumed deck reads as the curated
+    title ("Refutations") rather than the filename slug
+    ("refutation-drill"). Falls back to the input basename (case
+    preserved) when the source has no non-empty #+TITLE line.
+    """
+    for line in org_text.splitlines():
+        m = re.match(r"^#\+TITLE:\s*(.*\S)\s*$", line, re.IGNORECASE)
+        if m:
+            return m.group(1).strip()
     return input_path.stem
 
 
@@ -197,7 +211,7 @@ def main() -> int:
     )
     parser.add_argument(
         "--deck",
-        help="Deck name. Defaults to the input basename.",
+        help="Deck name. Defaults to the org #+TITLE, or the input basename.",
     )
     parser.add_argument(
         "--output",
@@ -213,7 +227,7 @@ def main() -> int:
         return 1
 
     org_text = input_path.read_text(encoding="utf-8")
-    deck_name = args.deck or default_deck_name(input_path)
+    deck_name = args.deck or default_deck_name(input_path, org_text)
     output_path: Path = (args.output or default_output_path(input_path)).expanduser().resolve()
     output_path.parent.mkdir(parents=True, exist_ok=True)
 
diff --git a/claude-templates/.ai/scripts/inbox-send.py b/claude-templates/.ai/scripts/inbox-send.py
index 5373bd4..1362a1f 100755
--- a/claude-templates/.ai/scripts/inbox-send.py
+++ b/claude-templates/.ai/scripts/inbox-send.py
@@ -136,8 +136,21 @@ def slugify_filename(stem: str, max_length: int = MAX_SLUG_LENGTH) -> str:
     return truncated.strip("-._")
 
 
+def display_name(path: Path) -> str:
+    """The name a project is referred to by — its basename with dots stripped.
+
+    Dotted directories (`.emacs.d`, `.dotfiles`) are awkward to name in
+    conversation, so they're addressed dot-stripped: `emacsd`, `dotfiles`.
+    """
+    return path.name.replace(".", "")
+
+
 def find_target(target_name: str, projects: list[Path]) -> Path | None:
-    """Resolve `target_name` against the project list (basename or numeric index)."""
+    """Resolve `target_name` against the project list (basename or numeric index).
+
+    An exact basename match wins. Failing that, a dot-stripped alias matches —
+    so `emacsd` resolves `.emacs.d` and `dotfiles` resolves `.dotfiles`.
+    """
     if target_name.isdigit():
         idx = int(target_name) - 1
         if 0 <= idx < len(projects):
@@ -146,6 +159,10 @@ def find_target(target_name: str, projects: list[Path]) -> Path | None:
     for p in projects:
         if p.name == target_name:
             return p
+    norm = target_name.replace(".", "")
+    for p in projects:
+        if display_name(p) == norm:
+            return p
     return None
 
 
@@ -206,9 +223,9 @@ def print_project_list(projects: list[Path], current: Path | None) -> None:
         print("No projects (.ai/ + inbox/) found under the configured roots.")
         return
     print(f"Available .ai projects ({len(others)}):")
-    width = max(len(p.name) for p in others)
+    width = max(len(display_name(p)) for p in others)
     for i, p in enumerate(others, 1):
-        print(f"  {i}. {p.name:<{width}}  {p}")
+        print(f"  {i}. {display_name(p):<{width}}  {p}")
 
 
 def main() -> int:
diff --git a/claude-templates/.ai/scripts/route_recommend.py b/claude-templates/.ai/scripts/route_recommend.py
new file mode 100644
index 0000000..7b36405
--- /dev/null
+++ b/claude-templates/.ai/scripts/route_recommend.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Wrap-up routing recommendation engine.
+
+Given an inbox keeper's text and a list of candidate project names, infer which
+project the item belongs to, with a confidence tier:
+
+  strong  a project's name (or its dot-stripped form, or a path containing it)
+          appears literally in the item
+  weak    a distinctive name token overlaps, but the full name doesn't
+  none    no overlap; the item stays put
+
+A multi-way tie at the top tier is ambiguous, so it downgrades to weak with a
+deterministic pick (most token overlap, then alphabetical). An empty candidate
+list yields none.
+
+The pure core is `recommend(item, projects) -> (destination, confidence)` — the
+shape the wrap-up router (Phase 4) and the process-inbox marker (Phase 2) both
+call. The CLI wires it to inbox-send.py's `discover_projects` so the candidate
+set is the same project universe inbox-send already knows.
+
+CLI:
+    route_recommend.py --item "<text>" [--exclude <current-project>]
+prints "<destination>\\t<confidence>" on a match, or "none".
+"""
+
+import argparse
+import importlib.util
+import re
+import sys
+from pathlib import Path
+
+# A distinctive-enough token for weak matching; shorter tokens (of, to, id) are
+# too noisy to route on.
+MIN_WEAK_TOKEN = 4
+
+_TOKEN_RE = re.compile(r"[a-z0-9]+")
+
+
+def _tokens(text: str) -> set[str]:
+    return set(_TOKEN_RE.findall(text.lower()))
+
+
+def _name_variants(name: str) -> set[str]:
+    """A project name and its dot-stripped alias (.emacs.d -> emacsd)."""
+    return {v for v in (name.lower(), name.replace(".", "").lower()) if v}
+
+
+def _literal_present(name: str, item_lower: str) -> bool:
+    """True if a name variant appears in the item on word-ish boundaries.
+
+    Boundaries keep 'home' from matching inside 'homeowner' while still
+    matching it inside a path ('~/code/home/...') or a hyphenated name.
+    """
+    for variant in _name_variants(name):
+        if re.search(r"(?<![a-z0-9])" + re.escape(variant) + r"(?![a-z0-9])", item_lower):
+            return True
+    return False
+
+
+def _tiebreak(candidates: list[str], item_tokens: set[str]) -> str:
+    """Most token overlap first, then alphabetical — deterministic."""
+    return sorted(candidates, key=lambda p: (-len(_tokens(p) & item_tokens), p))[0]
+
+
+def recommend(item: str, projects: list[str]) -> tuple[str | None, str]:
+    """Infer the destination project for `item` from `projects`.
+
+    Returns (destination, confidence). confidence is "strong" / "weak" / "none";
+    destination is None exactly when confidence is "none".
+    """
+    if not projects:
+        return (None, "none")
+
+    item_lower = item.lower()
+    item_tokens = _tokens(item)
+
+    strong: list[str] = []
+    weak: list[str] = []
+    for project in projects:
+        if _literal_present(project, item_lower):
+            strong.append(project)
+            continue
+        name_tokens = {t for t in _tokens(project) if len(t) >= MIN_WEAK_TOKEN}
+        if name_tokens & item_tokens:
+            weak.append(project)
+
+    if len(strong) == 1:
+        return (strong[0], "strong")
+    if len(strong) > 1:
+        return (_tiebreak(strong, item_tokens), "weak")
+    if len(weak) == 1:
+        return (weak[0], "weak")
+    if len(weak) > 1:
+        return (_tiebreak(weak, item_tokens), "weak")
+    return (None, "none")
+
+
+def _load_inbox_send():
+    """Load the sibling kebab-named inbox-send.py as a module for its discovery."""
+    path = Path(__file__).with_name("inbox-send.py")
+    spec = importlib.util.spec_from_file_location("inbox_send", path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"cannot load {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def discover_destination_names(exclude: str | None = None) -> list[str]:
+    """The candidate project names, reusing inbox-send's discovery.
+
+    `exclude` drops the current project (matched by exact name or dot-stripped
+    alias) so the engine never recommends routing an item to where it already is.
+    """
+    mod = _load_inbox_send()
+    names = [p.name for p in mod.discover_projects(mod.resolve_roots())]
+    if exclude:
+        drop = _name_variants(exclude)
+        names = [n for n in names if not (_name_variants(n) & drop)]
+    return names
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Recommend a routing destination for an inbox keeper.")
+    parser.add_argument("--item", required=True, help="the keeper's text")
+    parser.add_argument("--exclude", help="current project to exclude from candidates")
+    args = parser.parse_args()
+
+    projects = discover_destination_names(exclude=args.exclude)
+    destination, confidence = recommend(args.item, projects)
+    print("none" if destination is None else f"{destination}\t{confidence}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/claude-templates/.ai/scripts/tests/test_flashcard_to_anki.py b/claude-templates/.ai/scripts/tests/test_flashcard_to_anki.py
index 058b0cd..87008a8 100644
--- a/claude-templates/.ai/scripts/tests/test_flashcard_to_anki.py
+++ b/claude-templates/.ai/scripts/tests/test_flashcard_to_anki.py
@@ -34,14 +34,33 @@ def test_default_output_path_targets_phone_anki_dir(drill):
     assert result == Path.home() / "sync" / "phone" / "anki" / "health-drill.apkg"
 
 
-def test_default_deck_name_is_raw_basename(drill):
-    """Deck name is the input basename with case preserved; #+TITLE is ignored."""
-    assert drill.default_deck_name(Path("/x/deepsat.org")) == "deepsat"
+def test_default_deck_name_uses_org_title(drill):
+    """The #+TITLE drives the Anki deck name, not the filename slug."""
+    org = "#+TITLE: Refutations\n* Section\n** Q? :drill:\na\n"
+    assert drill.default_deck_name(Path("/x/refutation-drill.org"), org) == "Refutations"
 
 
-def test_default_deck_name_keeps_hyphens(drill):
-    """A hyphenated basename is kept verbatim rather than title-cased."""
-    assert drill.default_deck_name(Path("/x/health-drill.org")) == "health-drill"
+def test_default_deck_name_title_is_trimmed(drill):
+    """Surrounding whitespace on the #+TITLE value is stripped."""
+    org = "#+TITLE:   DeepSat Flashcards   \n"
+    assert drill.default_deck_name(Path("/x/deepsat.org"), org) == "DeepSat Flashcards"
+
+
+def test_default_deck_name_title_match_is_case_insensitive(drill):
+    """A lowercase #+title: keyword is still recognized."""
+    org = "#+title: Health Flashcards\n"
+    assert drill.default_deck_name(Path("/x/health-drill.org"), org) == "Health Flashcards"
+
+
+def test_default_deck_name_falls_back_to_basename_without_title(drill):
+    """No #+TITLE line falls back to the input basename, case preserved."""
+    org = "* Section\n** Q? :drill:\na\n"
+    assert drill.default_deck_name(Path("/x/deepsat.org"), org) == "deepsat"
+
+
+def test_default_deck_name_blank_title_falls_back_to_basename(drill):
+    """An empty #+TITLE value is ignored in favour of the basename."""
+    assert drill.default_deck_name(Path("/x/health-drill.org"), "#+TITLE:   \n") == "health-drill"
 
 
 # --- section_to_tag (pure) ---
diff --git a/claude-templates/.ai/scripts/tests/test_inbox_send.py b/claude-templates/.ai/scripts/tests/test_inbox_send.py
index a0094dc..cb60e63 100644
--- a/claude-templates/.ai/scripts/tests/test_inbox_send.py
+++ b/claude-templates/.ai/scripts/tests/test_inbox_send.py
@@ -97,6 +97,52 @@ class TestInboxSendDiscovery:
         result = run_script(["--list"], roots=[tmp_path / "does-not-exist"])
         assert result.returncode == 0
 
+    def test_inbox_send_list_displays_dot_stripped_name(self, project_root, run_script, tmp_path):
+        """Dotted project basenames display dot-stripped (.emacs.d → emacsd)."""
+        project_root(".emacs.d")
+        result = run_script(["--list"], roots=[tmp_path / "projects"])
+        assert "emacsd" in result.stdout
+
+
+class TestInboxSendDotAlias:
+    """A dotted project basename resolves both verbatim and dot-stripped."""
+
+    def test_resolves_by_dot_stripped_alias(self, project_root, run_script, tmp_path):
+        """'emacsd' delivers to the .emacs.d project."""
+        project_root(".emacs.d")
+        cwd = project_root("source")
+        run_script(
+            ["emacsd", "--text", "hi"],
+            cwd=cwd, roots=[tmp_path / "projects"],
+        )
+        files = list((tmp_path / "projects" / ".emacs.d" / "inbox").iterdir())
+        assert len(files) == 1
+
+    def test_resolves_by_exact_dotted_name_still(self, project_root, run_script, tmp_path):
+        """Backward-compat: the verbatim '.emacs.d' target still resolves."""
+        project_root(".emacs.d")
+        cwd = project_root("source")
+        run_script(
+            [".emacs.d", "--text", "hi"],
+            cwd=cwd, roots=[tmp_path / "projects"],
+        )
+        files = list((tmp_path / "projects" / ".emacs.d" / "inbox").iterdir())
+        assert len(files) == 1
+
+    def test_exact_match_wins_over_alias(self, project_root, run_script, tmp_path):
+        """An exact basename match is preferred over a dot-stripped collision."""
+        project_root("emacsd")        # exact
+        project_root(".emacs.d")      # would also normalize to 'emacsd'
+        cwd = project_root("source")
+        run_script(
+            ["emacsd", "--text", "hi"],
+            cwd=cwd, roots=[tmp_path / "projects"],
+        )
+        exact = list((tmp_path / "projects" / "emacsd" / "inbox").iterdir())
+        dotted = list((tmp_path / "projects" / ".emacs.d" / "inbox").iterdir())
+        assert len(exact) == 1
+        assert dotted == []
+
 
 # ----------------------------------------------------------------------
 # Slug derivation from text and from filenames
diff --git a/claude-templates/.ai/scripts/tests/test_route_recommend.py b/claude-templates/.ai/scripts/tests/test_route_recommend.py
new file mode 100644
index 0000000..acc4755
--- /dev/null
+++ b/claude-templates/.ai/scripts/tests/test_route_recommend.py
@@ -0,0 +1,124 @@
+"""Tests for route_recommend.py — the wrap-up routing recommendation engine.
+
+The core is a pure function recommend(item, projects) -> (destination, confidence):
+- strong: a project's name (or its dot-stripped form) appears literally in the item
+- weak:   a distinctive name token overlaps, but the full name doesn't
+- none:   no overlap; the item stays put (destination is None)
+
+A multi-way tie at the top tier downgrades to weak with a deterministic pick.
+An empty project list yields none.
+
+The CLI wires this to inbox-send.py's discover_projects (sandboxed here via the
+INBOX_SEND_ROOTS env var, the same hook inbox-send's own tests use).
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPTS = Path(__file__).parent.parent
+SCRIPT = SCRIPTS / "route_recommend.py"
+sys.path.insert(0, str(SCRIPTS))
+
+import route_recommend as rr  # noqa: E402
+
+
+# --- pure function: the five spec'd cases -----------------------------------
+
+def test_strong_match_named_literally():
+    dest, conf = rr.recommend("fix the rulesets refactor command", ["rulesets", "home", "work"])
+    assert (dest, conf) == ("rulesets", "strong")
+
+
+def test_strong_match_via_dot_stripped_name():
+    # ".emacs.d" addressed as "emacsd" in the item is still a literal hit.
+    dest, conf = rr.recommend("update the emacsd ai-term module", [".emacs.d", "rulesets"])
+    assert (dest, conf) == (".emacs.d", "strong")
+
+
+def test_strong_match_dotted_name_verbatim():
+    dest, conf = rr.recommend("patch .emacs.d startup", [".emacs.d", "rulesets"])
+    assert (dest, conf) == (".emacs.d", "strong")
+
+
+def test_weak_match_topic_token_only():
+    # "wttrin" is a token of "emacs-wttrin" but the full name isn't present.
+    dest, conf = rr.recommend("the wttrin weather bug", ["emacs-wttrin", "rulesets"])
+    assert (dest, conf) == ("emacs-wttrin", "weak")
+
+
+def test_no_match_stays_put():
+    dest, conf = rr.recommend("calibrate the telescope mount", ["rulesets", "deepsat"])
+    assert dest is None
+    assert conf == "none"
+
+
+def test_two_project_strong_tie_downgrades_to_weak():
+    # Both named literally → ambiguous → weak, deterministic tie-break (alphabetical).
+    dest, conf = rr.recommend("sync rulesets and home configs", ["rulesets", "home", "work"])
+    assert conf == "weak"
+    assert dest == "home"  # tie-break: most-overlap then alphabetical
+
+
+def test_empty_project_list_is_none():
+    assert rr.recommend("anything at all", []) == (None, "none")
+
+
+# --- boundary / robustness --------------------------------------------------
+
+def test_literal_name_requires_word_boundary():
+    # "home" must not match inside "homeowner".
+    dest, conf = rr.recommend("the homeowner association meeting", ["home", "rulesets"])
+    assert dest is None and conf == "none"
+
+
+def test_path_mention_counts_as_literal():
+    dest, conf = rr.recommend("edit ~/code/rulesets/Makefile", ["rulesets", "home"])
+    assert (dest, conf) == ("rulesets", "strong")
+
+
+def test_strong_beats_weak_when_both_present():
+    # "rulesets" named literally (strong) outranks an emacs-wttrin token hit (weak).
+    dest, conf = rr.recommend("the wttrin fix belongs in rulesets", ["rulesets", "emacs-wttrin"])
+    assert (dest, conf) == ("rulesets", "strong")
+
+
+# --- CLI + discovery reuse (sandboxed roots) --------------------------------
+
+def _run(args, roots, item):
+    import os
+    env = {"PATH": os.environ.get("PATH", ""), "HOME": os.environ.get("HOME", "/tmp"),
+           "INBOX_SEND_ROOTS": ":".join(str(r) for r in roots)}
+    return subprocess.run([sys.executable, str(SCRIPT), "--item", item, *args],
+                          capture_output=True, text=True, env=env)
+
+
+def _mk_project(tmp_path, name):
+    proj = tmp_path / "projects" / name
+    (proj / ".ai").mkdir(parents=True, exist_ok=True)
+    (proj / "inbox").mkdir(exist_ok=True)
+    return proj
+
+
+def test_cli_discovers_and_recommends(tmp_path):
+    _mk_project(tmp_path, "foo")
+    _mk_project(tmp_path, "bar")
+    r = _run([], roots=[tmp_path / "projects"], item="fix the foo widget")
+    assert r.returncode == 0
+    assert r.stdout.strip() == "foo\tstrong"
+
+
+def test_cli_no_match_prints_none(tmp_path):
+    _mk_project(tmp_path, "foo")
+    r = _run([], roots=[tmp_path / "projects"], item="unrelated grocery list")
+    assert r.returncode == 0
+    assert r.stdout.strip() == "none"
+
+
+def test_cli_exclude_drops_current_project(tmp_path):
+    _mk_project(tmp_path, "foo")
+    _mk_project(tmp_path, "bar")
+    # Item names foo, but foo is excluded as the current project → no other match.
+    r = _run(["--exclude", "foo"], roots=[tmp_path / "projects"], item="fix the foo widget")
+    assert r.returncode == 0
+    assert r.stdout.strip() == "none"