feat: integrate Ultraplan with tools and core toolsets for #840

Refs #840

docs/issue-954-verification.md

@@ -1,100 +0,0 @@
-# Issue #954 Verification — maps skill guest_house / camp_site / bakery
-
-Status: PASS
-
-## Drift noted
-
-Issue #954 asked for validation on `upstream/main` (commit `c5a814b23`).
-Fresh `forge/main` did not contain `skills/productivity/maps/`, so the forge branch was behind upstream for this feature cluster.
-This branch ports the upstream maps skill files into the forge checkout and adds regression coverage.
-
-## Automated verification
-
-Command:
-
-```bash
-pytest -q tests/skills/test_maps_client.py
-```
-
-Result:
-
-- 5 passed
-
-Coverage added:
-
-- maps skill files exist in the repo
-- `guest_house` category maps to `tourism=guest_house`
-- `camp_site` category maps to `tourism=camp_site`
-- `bakery` expands to both `shop=bakery` and `amenity=bakery`
-- dual-key bakery results dedupe correctly
-- skill documentation lists the new categories and supersedes `find-nearby`
-
-## Manual evidence
-
-### 1) guest_house lookup
-
-Command:
-
-```bash
-python3 skills/productivity/maps/scripts/maps_client.py nearby --near "Bath, United Kingdom" --category guest_house --limit 3
-```
-
-Observed results:
-
-- Henrietta House — 390.3 m
-- The Windsor — 437.2 m
-- The Old Rectory Bed & Breakfast — 495.7 m
-
-All returned `tourism=guest_house` in the raw tags.
-
-### 2) camp_site lookup
-
-Command:
-
-```bash
-python3 skills/productivity/maps/scripts/maps_client.py nearby --near "Yosemite Valley, California" --category camp_site --limit 5
-```
-
-Observed result:
-
-- Yellow Pine Administrative Campground — 90.3 m
-
-Returned `tourism=camp_site` in the raw tags.
-
-### 3) bakery lookup via `shop=bakery`
-
-Command:
-
-```bash
-python3 skills/productivity/maps/scripts/maps_client.py nearby --near "Lawrenceville, New Jersey" --category bakery --radius 5000 --limit 10
-```
-
-Observed results:
-
-- The Gingered Peach — 713.8 m
-- WildFlour Bakery — 741.9 m
-
-Both returned `shop=bakery` in the raw tags.
-
-### 4) bakery lookup via `amenity=bakery`
-
-Command:
-
-```bash
-python3 skills/productivity/maps/scripts/maps_client.py nearby --near "20735 Stevens Creek Boulevard, Cupertino, CA" --category bakery --radius 600 --limit 5
-```
-
-Observed result:
-
-- Paris Baguette — 28.6 m
-
-Returned `amenity=bakery` in the raw tags (and also includes `shop=bakery`), proving the dual-key union query reaches amenity-tagged bakeries too.
-
-## Conclusion
-
-PASS.
-
-- `guest_house` resolves correctly
-- `camp_site` resolves correctly
-- `bakery` resolves through both supported keys
-- forge/main drift from upstream/main was real and is addressed on this branch

hermes_cli/tools_config.py

@@ -57,7 +57,7 @@ CONFIGURABLE_TOOLSETS = [
     ("moa",             "🧠 Mixture of Agents",         "mixture_of_agents"),
     ("tts",             "🔊 Text-to-Speech",            "text_to_speech"),
     ("skills",          "📚 Skills",                    "list, view, manage"),
-    ("todo",            "📋 Task Planning",             "todo"),
+    ("todo",            "📋 Task Planning",             "todo, ultraplan"),
     ("memory",          "💾 Memory",                    "persistent memory across sessions"),
     ("session_search",  "🔎 Session Search",            "search past conversations"),
     ("clarify",         "❓ Clarifying Questions",      "clarify"),

skills/productivity/maps/SKILL.md

@@ -1,199 +0,0 @@
----
-name: maps
-description: >
-  Location intelligence — geocode a place, reverse-geocode coordinates,
-  find nearby places (46 POI categories), driving/walking/cycling
-  distance + time, turn-by-turn directions, timezone lookup, bounding
-  box + area for a named place, and POI search within a rectangle.
-  Uses OpenStreetMap + Overpass + OSRM. Free, no API key.
-version: 1.2.0
-author: Mibayy
-license: MIT
-metadata:
-  hermes:
-    tags: [maps, geocoding, places, routing, distance, directions, nearby, location, openstreetmap, nominatim, overpass, osrm]
-    category: productivity
-    requires_toolsets: [terminal]
-    supersedes: [find-nearby]
----
-
-# Maps Skill
-
-Location intelligence using free, open data sources. 8 commands, 44 POI
-categories, zero dependencies (Python stdlib only), no API key required.
-
-Data sources: OpenStreetMap/Nominatim, Overpass API, OSRM, TimeAPI.io.
-
-This skill supersedes the old `find-nearby` skill — all of find-nearby's
-functionality is covered by the `nearby` command below, with the same
-`--near "<place>"` shortcut and multi-category support.
-
-## When to Use
-
-- User sends a Telegram location pin (latitude/longitude in the message) → `nearby`
-- User wants coordinates for a place name → `search`
-- User has coordinates and wants the address → `reverse`
-- User asks for nearby restaurants, hospitals, pharmacies, hotels, etc. → `nearby`
-- User wants driving/walking/cycling distance or travel time → `distance`
-- User wants turn-by-turn directions between two places → `directions`
-- User wants timezone information for a location → `timezone`
-- User wants to search for POIs within a geographic area → `area` + `bbox`
-
-## Prerequisites
-
-Python 3.8+ (stdlib only — no pip installs needed).
-
-Script path: `~/.hermes/skills/maps/scripts/maps_client.py`
-
-## Commands
-
-```bash
-MAPS=~/.hermes/skills/maps/scripts/maps_client.py
-```
-
-### search — Geocode a place name
-
-```bash
-python3 $MAPS search "Eiffel Tower"
-python3 $MAPS search "1600 Pennsylvania Ave, Washington DC"
-```
-
-Returns: lat, lon, display name, type, bounding box, importance score.
-
-### reverse — Coordinates to address
-
-```bash
-python3 $MAPS reverse 48.8584 2.2945
-```
-
-Returns: full address breakdown (street, city, state, country, postcode).
-
-### nearby — Find places by category
-
-```bash
-# By coordinates (from a Telegram location pin, for example)
-python3 $MAPS nearby 48.8584 2.2945 restaurant --limit 10
-python3 $MAPS nearby 40.7128 -74.0060 hospital --radius 2000
-
-# By address / city / zip / landmark — --near auto-geocodes
-python3 $MAPS nearby --near "Times Square, New York" --category cafe
-python3 $MAPS nearby --near "90210" --category pharmacy
-
-# Multiple categories merged into one query
-python3 $MAPS nearby --near "downtown austin" --category restaurant --category bar --limit 10
-```
-
-46 categories: restaurant, cafe, bar, hospital, pharmacy, hotel, guest_house,
-camp_site, supermarket, atm, gas_station, parking, museum, park, school,
-university, bank, police, fire_station, library, airport, train_station,
-bus_stop, church, mosque, synagogue, dentist, doctor, cinema, theatre, gym,
-swimming_pool, post_office, convenience_store, bakery, bookshop, laundry,
-car_wash, car_rental, bicycle_rental, taxi, veterinary, zoo, playground,
-stadium, nightclub.
-
-Each result includes: `name`, `address`, `lat`/`lon`, `distance_m`,
-`maps_url` (clickable Google Maps link), `directions_url` (Google Maps
-directions from the search point), and promoted tags when available —
-`cuisine`, `hours` (opening_hours), `phone`, `website`.
-
-### distance — Travel distance and time
-
-```bash
-python3 $MAPS distance "Paris" --to "Lyon"
-python3 $MAPS distance "New York" --to "Boston" --mode driving
-python3 $MAPS distance "Big Ben" --to "Tower Bridge" --mode walking
-```
-
-Modes: driving (default), walking, cycling. Returns road distance, duration,
-and straight-line distance for comparison.
-
-### directions — Turn-by-turn navigation
-
-```bash
-python3 $MAPS directions "Eiffel Tower" --to "Louvre Museum" --mode walking
-python3 $MAPS directions "JFK Airport" --to "Times Square" --mode driving
-```
-
-Returns numbered steps with instruction, distance, duration, road name, and
-maneuver type (turn, depart, arrive, etc.).
-
-### timezone — Timezone for coordinates
-
-```bash
-python3 $MAPS timezone 48.8584 2.2945
-python3 $MAPS timezone 35.6762 139.6503
-```
-
-Returns timezone name, UTC offset, and current local time.
-
-### area — Bounding box and area for a place
-
-```bash
-python3 $MAPS area "Manhattan, New York"
-python3 $MAPS area "London"
-```
-
-Returns bounding box coordinates, width/height in km, and approximate area.
-Useful as input for the bbox command.
-
-### bbox — Search within a bounding box
-
-```bash
-python3 $MAPS bbox 40.75 -74.00 40.77 -73.98 restaurant --limit 20
-```
-
-Finds POIs within a geographic rectangle. Use `area` first to get the
-bounding box coordinates for a named place.
-
-## Working With Telegram Location Pins
-
-When a user sends a location pin, the message contains `latitude:` and
-`longitude:` fields. Extract those and pass them straight to `nearby`:
-
-```bash
-# User sent a pin at 36.17, -115.14 and asked "find cafes nearby"
-python3 $MAPS nearby 36.17 -115.14 cafe --radius 1500
-```
-
-Present results as a numbered list with names, distances, and the
-`maps_url` field so the user gets a tap-to-open link in chat. For "open
-now?" questions, check the `hours` field; if missing or unclear, verify
-with `web_search` since OSM hours are community-maintained and not always
-current.
-
-## Workflow Examples
-
-**"Find Italian restaurants near the Colosseum":**
-1. `nearby --near "Colosseum Rome" --category restaurant --radius 500`
-   — one command, auto-geocoded
-
-**"What's near this location pin they sent?":**
-1. Extract lat/lon from the Telegram message
-2. `nearby LAT LON cafe --radius 1500`
-
-**"How do I walk from hotel to conference center?":**
-1. `directions "Hotel Name" --to "Conference Center" --mode walking`
-
-**"What restaurants are in downtown Seattle?":**
-1. `area "Downtown Seattle"` → get bounding box
-2. `bbox S W N E restaurant --limit 30`
-
-## Pitfalls
-
-- Nominatim ToS: max 1 req/s (handled automatically by the script)
-- `nearby` requires lat/lon OR `--near "<address>"` — one of the two is needed
-- OSRM routing coverage is best for Europe and North America
-- Overpass API can be slow during peak hours; the script automatically
-  falls back between mirrors (overpass-api.de → overpass.kumi.systems)
-- `distance` and `directions` use `--to` flag for the destination (not positional)
-- If a zip code alone gives ambiguous results globally, include country/state
-
-## Verification
-
-```bash
-python3 ~/.hermes/skills/maps/scripts/maps_client.py search "Statue of Liberty"
-# Should return lat ~40.689, lon ~-74.044
-
-python3 ~/.hermes/skills/maps/scripts/maps_client.py nearby --near "Times Square" --category restaurant --limit 3
-# Should return a list of restaurants within ~500m of Times Square
-```

tests/skills/test_maps_client.py

@@ -1,135 +0,0 @@
-"""Regression tests for the bundled maps skill."""
-
-from __future__ import annotations
-
-import importlib.util
-from pathlib import Path
-from types import SimpleNamespace
-
-SCRIPT_PATH = (
-    Path(__file__).resolve().parents[2]
-    / "skills/productivity/maps/scripts/maps_client.py"
-)
-SKILL_PATH = (
-    Path(__file__).resolve().parents[2]
-    / "skills/productivity/maps/SKILL.md"
-)
-
-
-def load_module():
-    assert SCRIPT_PATH.exists(), f"missing maps client script: {SCRIPT_PATH}"
-    spec = importlib.util.spec_from_file_location("maps_client_test", SCRIPT_PATH)
-    module = importlib.util.module_from_spec(spec)
-    assert spec.loader is not None
-    spec.loader.exec_module(module)
-    return module
-
-
-def test_maps_skill_files_exist():
-    assert SCRIPT_PATH.exists()
-    assert SKILL_PATH.exists()
-
-
-def test_category_tags_cover_guest_house_camp_site_and_dual_key_bakery():
-    module = load_module()
-
-    assert module.CATEGORY_TAGS["guest_house"] == ("tourism", "guest_house")
-    assert module.CATEGORY_TAGS["camp_site"] == ("tourism", "camp_site")
-    assert module.CATEGORY_TAGS["bakery"] == [
-        ("shop", "bakery"),
-        ("amenity", "bakery"),
-    ]
-    assert module._tags_for("bakery") == [
-        ("shop", "bakery"),
-        ("amenity", "bakery"),
-    ]
-
-
-def test_build_overpass_queries_include_all_supported_tags():
-    module = load_module()
-
-    bakery_query = module.build_overpass_nearby(
-        None,
-        None,
-        40.0,
-        -74.0,
-        500,
-        10,
-        tag_pairs=module._tags_for("bakery"),
-    )
-    assert 'node["shop"="bakery"]' in bakery_query
-    assert 'way["shop"="bakery"]' in bakery_query
-    assert 'node["amenity"="bakery"]' in bakery_query
-    assert 'way["amenity"="bakery"]' in bakery_query
-
-    guest_house_query = module.build_overpass_nearby(
-        None,
-        None,
-        40.0,
-        -74.0,
-        500,
-        10,
-        tag_pairs=module._tags_for("guest_house"),
-    )
-    assert 'node["tourism"="guest_house"]' in guest_house_query
-    assert 'way["tourism"="guest_house"]' in guest_house_query
-
-    camp_site_bbox = module.build_overpass_bbox(
-        None,
-        None,
-        39.0,
-        -75.0,
-        41.0,
-        -73.0,
-        10,
-        tag_pairs=module._tags_for("camp_site"),
-    )
-    assert 'node["tourism"="camp_site"]' in camp_site_bbox
-    assert 'way["tourism"="camp_site"]' in camp_site_bbox
-
-
-def test_cmd_nearby_dedupes_dual_tag_bakery_results(monkeypatch, capsys):
-    module = load_module()
-
-    duplicate_bakery = {
-        "elements": [
-            {
-                "type": "node",
-                "id": 101,
-                "lat": 40.0,
-                "lon": -74.0,
-                "tags": {"name": "Wild Flour", "shop": "bakery"},
-            },
-            {
-                "type": "node",
-                "id": 101,
-                "lat": 40.0,
-                "lon": -74.0,
-                "tags": {"name": "Wild Flour", "amenity": "bakery"},
-            },
-        ]
-    }
-
-    monkeypatch.setattr(module, "overpass_query", lambda query: duplicate_bakery)
-    args = SimpleNamespace(
-        lat="40.0",
-        lon="-74.0",
-        near=None,
-        category="bakery",
-        category_list=[],
-        radius=500,
-        limit=10,
-    )
-
-    module.cmd_nearby(args)
-    out = capsys.readouterr().out
-    assert '"count": 1' in out
-    assert '"Wild Flour"' in out
-
-
-def test_skill_doc_lists_new_categories_and_supersession():
-    text = SKILL_PATH.read_text(encoding="utf-8")
-    assert "guest_house" in text
-    assert "camp_site" in text
-    assert "bakery" in text
-    assert "supersedes: [find-nearby]" in text

tests/tools/test_registry.py

@@ -294,22 +294,32 @@ class TestBuiltinDiscovery:
             "tools.browser_tool",
             "tools.clarify_tool",
             "tools.code_execution_tool",
+            "tools.crisis_tool",
             "tools.cronjob_tools",
             "tools.delegate_tool",
             "tools.file_tools",
             "tools.homeassistant_tool",
             "tools.image_generation_tool",
+            "tools.local_inference_tool",
             "tools.memory_tool",
             "tools.mixture_of_agents_tool",
             "tools.process_registry",
             "tools.rl_training_tool",
+            "tools.scavenger_fixer",
             "tools.send_message_tool",
             "tools.session_search_tool",
             "tools.skill_manager_tool",
             "tools.skills_tool",
+            "tools.sovereign_router",
+            "tools.sovereign_scavenger",
+            "tools.sovereign_teleport",
+            "tools.static_analyzer",
+            "tools.symbolic_verify",
             "tools.terminal_tool",
             "tools.todo_tool",
             "tools.tts_tool",
+            "tools.ultraplan",
+            "tools.verify_tool",
             "tools.vision_tools",
             "tools.web_tools",
         }

tests/tools/test_ultraplan_tool.py

@@ -0,0 +1,81 @@
+import json
+from pathlib import Path
+
+from toolsets import resolve_toolset
+from tools.registry import registry
+
+
+def test_create_action_saves_markdown_and_json(tmp_path):
+    from tools.ultraplan import ultraplan_tool
+
+    result = json.loads(
+        ultraplan_tool(
+            action="create",
+            mission="Daily autonomous planning",
+            streams=[
+                {
+                    "id": "A",
+                    "name": "Backlog burn",
+                    "phases": [
+                        {"id": "A1", "name": "Triage", "artifact": "issue list"},
+                        {"id": "A2", "name": "Ship", "dependencies": ["A1"], "artifact": "PR"},
+                    ],
+                }
+            ],
+            base_dir=str(tmp_path),
+        )
+    )
+
+    assert result["success"] is True
+    assert Path(result["file_path"]).exists()
+    assert Path(result["json_path"]).exists()
+    assert "Work Streams" in Path(result["file_path"]).read_text(encoding="utf-8")
+
+
+def test_load_action_returns_saved_plan(tmp_path):
+    from tools.ultraplan import ultraplan_tool
+
+    created = json.loads(
+        ultraplan_tool(
+            action="create",
+            date="20260422",
+            mission="Mission from saved plan",
+            base_dir=str(tmp_path),
+        )
+    )
+    loaded = json.loads(
+        ultraplan_tool(
+            action="load",
+            date="20260422",
+            base_dir=str(tmp_path),
+        )
+    )
+
+    assert created["success"] is True
+    assert loaded["success"] is True
+    assert loaded["plan"]["mission"] == "Mission from saved plan"
+    assert loaded["file_path"].endswith("ultraplan_20260422.md")
+
+
+def test_cron_spec_returns_daily_schedule_and_prompt():
+    from tools.ultraplan import ultraplan_tool
+
+    result = json.loads(ultraplan_tool(action="cron_spec"))
+
+    assert result["success"] is True
+    assert result["schedule"] == "0 6 * * *"
+    assert "Ultraplan" in result["prompt"]
+    assert "ultraplan_YYYYMMDD.md" in result["prompt"]
+
+
+def test_registry_registers_ultraplan_tool():
+    import tools.ultraplan  # noqa: F401
+
+    entry = registry.get_entry("ultraplan")
+    assert entry is not None
+    assert entry.toolset == "todo"
+
+
+def test_default_toolsets_include_ultraplan():
+    assert "ultraplan" in resolve_toolset("todo")
+    assert "ultraplan" in resolve_toolset("hermes-cli")

tools/ultraplan.py

@@ -290,6 +290,9 @@ def load_ultraplan(date: str, base_dir: Path = None) -> Optional[Ultraplan]:
         return None
 
 
+DEFAULT_ULTRAPLAN_SCHEDULE = "0 6 * * *"
+
+
 def generate_daily_cron_prompt() -> str:
     """Generate the prompt for the daily ultraplan cron job."""
     return """Generate today's Ultraplan.
@@ -298,9 +301,9 @@ Steps:
 1. Check open Gitea issues assigned to you
 2. Check open PRs needing review
 3. Check fleet health status
-4. Decompose work into parallel streams
-5. Generate ultraplan_YYYYMMDD.md
-6. File Gitea issue with the plan
+4. Decompose work into parallel streams with concrete phases and artifacts
+5. Use the ultraplan tool to save ~/.timmy/cron/ultraplan_YYYYMMDD.md and the matching JSON sidecar
+6. Optionally file a Gitea issue with the plan summary
 
 Output format:
 - Mission statement
@@ -308,3 +311,176 @@ Output format:
 - Dependency map
 - Success metrics
 """
+
+
+def generate_daily_cron_job_spec(schedule: str = DEFAULT_ULTRAPLAN_SCHEDULE) -> Dict[str, str]:
+    """Return a reusable cron job spec for daily Ultraplan generation."""
+    return {
+        "name": "Daily Ultraplan",
+        "schedule": schedule,
+        "prompt": generate_daily_cron_prompt(),
+        "path_pattern": "~/.timmy/cron/ultraplan_YYYYMMDD.md",
+    }
+
+
+def _resolve_base_dir(base_dir: Optional[str | Path]) -> Path:
+    """Normalize the requested Ultraplan base directory."""
+    if base_dir is None:
+        return Path.home() / ".timmy" / "cron"
+    return Path(base_dir).expanduser()
+
+
+def ultraplan_tool(
+    action: str,
+    date: Optional[str] = None,
+    mission: str = "",
+    streams: Optional[List[Dict[str, Any]]] = None,
+    metrics: Optional[Dict[str, Any]] = None,
+    notes: str = "",
+    base_dir: Optional[str] = None,
+) -> str:
+    """Create/load Ultraplan artifacts and expose a daily cron spec."""
+    from tools.registry import tool_error, tool_result
+
+    action = (action or "").strip().lower()
+    resolved_base_dir = _resolve_base_dir(base_dir)
+
+    try:
+        if action == "create":
+            plan = create_ultraplan(date=date, mission=mission, streams=streams or [])
+            if metrics:
+                plan.metrics = metrics
+            if notes:
+                plan.notes = notes
+            md_path = save_ultraplan(plan, base_dir=resolved_base_dir)
+            json_path = resolved_base_dir / f"ultraplan_{plan.date}.json"
+            return tool_result(
+                success=True,
+                action="create",
+                date=plan.date,
+                file_path=str(md_path),
+                json_path=str(json_path),
+                plan=plan.to_dict(),
+            )
+
+        if action == "load":
+            plan_date = date or datetime.now().strftime("%Y%m%d")
+            plan = load_ultraplan(plan_date, base_dir=resolved_base_dir)
+            if plan is None:
+                return tool_error(
+                    f"No Ultraplan found for {plan_date}",
+                    success=False,
+                    action="load",
+                    date=plan_date,
+                )
+            return tool_result(
+                success=True,
+                action="load",
+                date=plan.date,
+                file_path=str(resolved_base_dir / f"ultraplan_{plan.date}.md"),
+                json_path=str(resolved_base_dir / f"ultraplan_{plan.date}.json"),
+                plan=plan.to_dict(),
+                markdown=plan.to_markdown(),
+            )
+
+        if action == "cron_spec":
+            spec = generate_daily_cron_job_spec()
+            return tool_result(success=True, action="cron_spec", **spec)
+
+        return tool_error(
+            f"Unknown Ultraplan action: {action}",
+            success=False,
+            action=action,
+        )
+    except Exception as e:
+        return tool_error(f"Ultraplan {action or 'tool'} failed: {e}", success=False, action=action)
+
+
+ULTRAPLAN_SCHEMA = {
+    "name": "ultraplan",
+    "description": (
+        "Create or load daily Ultraplan planning artifacts under ~/.timmy/cron/ and "
+        "return a reusable cron spec for autonomous planning. Use this when you want "
+        "a concrete markdown/json plan file with streams, phases, dependencies, and metrics."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["create", "load", "cron_spec"],
+                "description": "Operation to perform",
+            },
+            "date": {
+                "type": "string",
+                "description": "Plan date as YYYYMMDD. Defaults to today for create/load.",
+            },
+            "mission": {
+                "type": "string",
+                "description": "High-level mission statement for today's plan.",
+            },
+            "streams": {
+                "type": "array",
+                "description": "Optional work streams with phases/artifacts/dependencies for create.",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "id": {"type": "string"},
+                        "name": {"type": "string"},
+                        "phases": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "id": {"type": "string"},
+                                    "name": {"type": "string"},
+                                    "description": {"type": "string"},
+                                    "artifact": {"type": "string"},
+                                    "dependencies": {
+                                        "type": "array",
+                                        "items": {"type": "string"},
+                                    },
+                                },
+                                "required": ["name"],
+                            },
+                        },
+                    },
+                    "required": ["name"],
+                },
+            },
+            "metrics": {
+                "type": "object",
+                "description": "Optional success metrics to store on the plan.",
+                "additionalProperties": True,
+            },
+            "notes": {
+                "type": "string",
+                "description": "Optional free-form notes appended to the saved plan.",
+            },
+            "base_dir": {
+                "type": "string",
+                "description": "Optional override for the Ultraplan storage directory.",
+            },
+        },
+        "required": ["action"],
+    },
+}
+
+
+from tools.registry import registry
+
+registry.register(
+    name="ultraplan",
+    toolset="todo",
+    schema=ULTRAPLAN_SCHEMA,
+    handler=lambda args, **_kw: ultraplan_tool(
+        action=args.get("action", ""),
+        date=args.get("date"),
+        mission=args.get("mission", ""),
+        streams=args.get("streams"),
+        metrics=args.get("metrics"),
+        notes=args.get("notes", ""),
+        base_dir=args.get("base_dir"),
+    ),
+    emoji="🗺️",
+)

toolsets.py

@@ -47,7 +47,7 @@ _HERMES_CORE_TOOLS = [
     # Text-to-speech
     "text_to_speech",
     # Planning & memory
-    "todo", "memory",
+    "todo", "ultraplan", "memory",
     # Session history search
     "session_search",
     # Clarifying questions
@@ -157,8 +157,8 @@ TOOLSETS = {
     },
     
     "todo": {
-        "description": "Task planning and tracking for multi-step work",
-        "tools": ["todo"],
+        "description": "Task planning and tracking for multi-step work, including daily Ultraplan artifacts",
+        "tools": ["todo", "ultraplan"],
         "includes": []
     },