jott-cli 0.5.3__tar.gz → 0.5.4__tar.gz

{jott_cli-0.5.3/jott_cli.egg-info → jott_cli-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.5.3
+Version: 0.5.4
 Summary: Feature-rich interactive CLI task manager with AI integration, calendar sync, and keyword automation
 Author-email: Scott Anderson <sonander@gmail.com>
 Maintainer-email: Scott Anderson <sonander@gmail.com>

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/__init__.py

@@ -7,7 +7,7 @@ import importlib.util
 import os
 from pathlib import Path
 
-__version__ = "0.5.2"
+__version__ = "0.5.4"
 
 # When building Sphinx docs, skip the dynamic import bridge and heavy deps.
 # Set JOT_SPHINX_BUILD=1 in docs/sphinx/conf.py before importing jot.

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/_app_navigation_mixin.py

@@ -38,7 +38,7 @@ class AppNavigationMixin:
         return False
 
     def _handle_toggle(self, key):
-        """Process shared toggle keys A/O/Y/F/?.  Returns True if
+        """Process shared toggle keys A/O/Y/F.  Returns True if
         the key was a toggle key."""
         st = self.state
 
@@ -47,7 +47,6 @@ class AppNavigationMixin:
             'O': ('sort_by_day', None),
             'Y': ('show_today_only', None),
             'F': ('show_notes_inline', 'inline notes'),
-            '?': ('show_shortcuts', 'shortcuts'),
         }
 
         if key not in toggle_map:

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/_dispatch_mixin.py

@@ -30,7 +30,7 @@ class DispatchMixin:
             st.input_buffer = st.input_buffer[:-1]
             return
 
-        if key == 'C':
+        if key == '\x03':  # Ctrl+C
             self._handle_switch_category()
             return
 
@@ -296,11 +296,27 @@ class DispatchMixin:
     def _handle_dot_chord(self):
         """Handle '.' leader key — wait for second key to form chord."""
         st = self.state
-        second = get_key(timeout=0.3)
-        if second == 'c':
+        second = get_key(timeout=0.5)
+        if second == 's':
             self._toggle_collapse()
             st.input_buffer = ""
             return
+        if second == 'c':
+            self.command_handler.copy_to_clipboard()
+            st.input_buffer = ""
+            return
+        if second == '?':
+            st.show_shortcuts = not st.show_shortcuts
+            st.input_buffer = ""
+            return
+        if second == 'i':
+            self.command_handler.import_from_gcal()
+            st.input_buffer = ""
+            return
+        if second == 'g':
+            self.command_handler.web_search()
+            st.input_buffer = ""
+            return
         # Not a chord — treat '.' as normal input
         st.input_buffer += '.'
         if second and second != '.':

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/app.py

@@ -59,16 +59,13 @@ class App(DispatchMixin, AppNavigationMixin):
         'M': 'move_task_to_project',
         '\x0b': 'copy_task_to_project',        # Ctrl+K
         '\x14': 'transfer_task_to_category',       # Ctrl+T
-        'S': 'web_search',
         '\x13': 'sync_subtasks',                # Ctrl+S
-        'D': 'delete_current',
+        '\x04': 'delete_current',              # Ctrl+D
         'W': 'assign_day',
         'P': 'set_priority',
         'H': 'set_priority_high',
         'X': 'set_status',
         'G': 'export_to_gcal',
-        'I': 'import_from_gcal',
-        'K': 'copy_to_clipboard',
         'E': 'trigger_keyword_action',
         'N': 'edit_task_notes',
         '\x15': 'open_url',                     # Ctrl+U

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/commands/handler.py

@@ -35,7 +35,7 @@ class CommandHandler(
             'a': self.add_task,
             'c': self.set_current,
             'd': self.delete_task,
-            'D': self.delete_current,
+            '\x04': self.delete_current,   # Ctrl+D
             'e': self.edit_task,
             'E': self.edit_current,
             'M': self.move_task_to_project,
@@ -46,7 +46,7 @@ class CommandHandler(
 
     def handle(self, command):
         """Handle a command"""
-        # Check for exact match first (for case-sensitive commands like 'D')
+        # Check for exact match first (for case-sensitive commands like 'E')
         handler = self.commands.get(command)
         if not handler:
             # Fall back to lowercase

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/projects/registry.py

@@ -117,6 +117,14 @@ class ProjectRegistry:
             entry["usage_count"] = entry.get("usage_count", 0) + 1
         self._save_registry()
 
+    def is_path_registered(self, path):
+        """Check if a directory path is already registered"""
+        resolved = str(Path(path).expanduser().resolve())
+        for entry in self.projects.values():
+            if _get_path(entry) == resolved:
+                return True
+        return False
+
     def refresh(self):
         """Re-run auto-discovery"""
         self._auto_discover()

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/ui/display_footer.py

@@ -33,7 +33,7 @@ def _render_quick_add(input_buffer, show_shortcuts):
         f"{GREEN}[QUICK ADD]{RESET} Type task, {BOLD}Enter{RESET} "
         f"to save | {BOLD}/{RESET}: search | {BOLD}ESC{RESET}: "
         f"commands | {BOLD}Shift+V{RESET}: multi-select | "
-        f"{BOLD}?{RESET}: shortcuts"
+        f"{BOLD}.?{RESET}: shortcuts"
     )
     if show_shortcuts:
         from jot.ui.display_help import display_categorized_shortcuts

{jott_cli-0.5.3 → jott_cli-0.5.4}/jot/ui/display_help.py

@@ -11,7 +11,7 @@ def display_categorized_shortcuts():
             ("Tab", "Cycle through categories"),
             ("Ctrl+F", "Fuzzy search tasks"),
             ("Shift+Z", "Switch project"),
-            ("Shift+C", "Switch category"),
+            ("Ctrl+C", "Switch category"),
             ("Shift+L", "Toggle all categories view"),
         ],
         "Task Management": [
@@ -40,7 +40,7 @@ def display_categorized_shortcuts():
             ("Shift+W", "Assign day to task"),
             ("Shift+O", "Toggle day sorting"),
             ("Shift+Y", "Toggle today filter"),
-            ("Shift+D", "Mark current as done"),
+            ("Ctrl+D", "Mark current as done"),
             ("Shift+J", "Mark as agent task"),
             ("*", "Highlight color picker"),
             ("~", "Quick highlight toggle"),
@@ -64,12 +64,12 @@ def display_categorized_shortcuts():
             ("Shift+4", "AI task suggestion"),
             ("Shift+E", "Execute keyword action"),
             ("Shift+G", "Google Calendar setup"),
-            ("Shift+I", "Import from Google Calendar"),
-            ("Shift+K", "Copy task to clipboard"),
+            (".i", "Import from Google Calendar"),
+            (".c", "Copy task to clipboard"),
             ("Ctrl+U", "Open URLs in task"),
         ],
         "System": [
-            ("h/?", "Show this help"),
+            ("h/.?", "Show this help"),
             ("r", "Refresh display"),
             ("Ctrl+R", "Register current project"),
             ("q", "Quit"),
@@ -119,7 +119,7 @@ def display_help():
   {CYAN}Tab{RESET}              Cycle through categories
   {CYAN}Ctrl+F{RESET}           Fuzzy search tasks
   {CYAN}Shift+Z{RESET}          Switch between projects
-  {CYAN}Shift+C{RESET}          Switch between categories
+  {CYAN}Ctrl+C{RESET}           Switch between categories
   {CYAN}Shift+L{RESET}          Toggle all categories view
 
 {BOLD}TASK MANAGEMENT:{RESET}
@@ -147,7 +147,7 @@ def display_help():
   {CYAN}Shift+W{RESET}          Assign day to task
   {CYAN}Shift+O{RESET}          Toggle day sorting
   {CYAN}Shift+Y{RESET}          Toggle today filter
-  {CYAN}Shift+D{RESET}          Mark current task as done
+  {CYAN}Ctrl+D{RESET}           Mark current task as done
   {CYAN}Shift+J{RESET}          Mark task for agent/AI assistance
   {CYAN}*{RESET}                Highlight color picker (6 colors)
   {CYAN}~{RESET}                Quick highlight toggle (default color)
@@ -185,7 +185,7 @@ def display_help():
 
   {CYAN}jott -c backend{RESET}  Start in "backend" category
   {CYAN}Tab{RESET}              Cycle through categories
-  {CYAN}Shift+C{RESET}          Create/switch categories interactively
+  {CYAN}Ctrl+C{RESET}           Create/switch categories interactively
   {CYAN}m{RESET}                Move task between categories
 
 {BOLD}PROJECTS:{RESET}
@@ -200,8 +200,8 @@ def display_help():
   {CYAN}Shift+4{RESET}          AI task suggestion
   {CYAN}Shift+E{RESET}          Execute keyword action for task
   {CYAN}Shift+G{RESET}          Set up Google Calendar integration
-  {CYAN}Shift+I{RESET}          Import tasks from Google Calendar
-  {CYAN}Shift+K{RESET}          Copy task text to clipboard
+  {CYAN}.i{RESET}               Import tasks from Google Calendar
+  {CYAN}.c{RESET}               Copy task text to clipboard
   {CYAN}Ctrl+U{RESET}           Open URLs found in task text
 
 {BOLD}FUZZY SEARCH:{RESET}
@@ -212,7 +212,7 @@ def display_help():
   {CYAN}Esc{RESET}              Exit search
 
 {BOLD}SYSTEM:{RESET}
-  {CYAN}h or ?{RESET}           Show keyboard shortcuts
+  {CYAN}h or .?{RESET}          Show keyboard shortcuts
   {CYAN}r{RESET}                Refresh display
   {CYAN}Ctrl+R{RESET}           Register current project in registry
   {CYAN}q{RESET}                Quit
@@ -227,7 +227,7 @@ def display_help():
 
 {BOLD}CONFIGURATION:{RESET}
   • Edit ~/.jot-keywords.json to customize keyword actions
-  • Category colors: Edit category config (Shift+C)
+  • Category colors: Edit category config (Ctrl+C)
   • Global vs local: Use -g flag or create global categories
 
 {DIM}For more info: https://github.com/your-repo/jot{RESET}"""

{jott_cli-0.5.3 → jott_cli-0.5.4/jott_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.5.3
+Version: 0.5.4
 Summary: Feature-rich interactive CLI task manager with AI integration, calendar sync, and keyword automation
 Author-email: Scott Anderson <sonander@gmail.com>
 Maintainer-email: Scott Anderson <sonander@gmail.com>

{jott_cli-0.5.3 → jott_cli-0.5.4}/pyproject.toml

@@ -7,7 +7,7 @@ include = ["jot", "jot.*"]
 
 [project]
 name = "jott-cli"
-version = "0.5.3"
+version = "0.5.4"
 description = "Feature-rich interactive CLI task manager with AI integration, calendar sync, and keyword automation"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.6"

{jott_cli-0.5.3 → jott_cli-0.5.4}/tests/test_dispatch.py

@@ -82,13 +82,12 @@ class TestQuickAddDispatchTable:
     def test_critical_keys_present(self):
         """Verify that the most important shortcuts are wired up."""
         critical = {
-            'D': 'delete_current',
+            '\x04': 'delete_current',  # Ctrl+D
             'W': 'assign_day',
             'P': 'set_priority',
             'X': 'set_status',
             'M': 'move_task_to_project',
             'N': 'edit_task_notes',
-            'S': 'web_search',
             '\x14': 'transfer_task_to_category',  # Ctrl+T
         }
         for key, expected_method in critical.items():

{jott_cli-0.5.3 → jott_cli-0.5.4}/tests/test_jot.py

@@ -666,9 +666,7 @@ class TestProjectRegistry:
         with tempfile.TemporaryDirectory() as tmpdir:
             registry_file = Path(tmpdir) / 'test-registry.json'
             # Write old format directly
-            registry_file.write_text(json.dumps({
-                "old-project": "/path/old"
-            }))
+            registry_file.write_text(json.dumps({"old-project": "/path/old"}))
 
             pr = ProjectRegistry(registry_file=str(registry_file))
 
@@ -706,6 +704,112 @@ class TestProjectRegistry:
             items = pr.list_projects_by_usage()
             assert items[0][2] == 2  # Usage count preserved
 
+    def test_is_path_registered_new_format(self):
+        """Test is_path_registered with new dict format"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            registry_file = Path(tmpdir) / 'test-registry.json'
+            registry_file.write_text('{}')
+
+            pr = ProjectRegistry(registry_file=str(registry_file))
+            project_path = Path(tmpdir) / 'myproject'
+            project_path.mkdir()
+            pr.register_project("myproject", str(project_path))
+
+            assert pr.is_path_registered(str(project_path)) is True
+            assert pr.is_path_registered("/nonexistent/path") is False
+
+    def test_is_path_registered_old_format(self):
+        """Test is_path_registered with old string format"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            registry_file = Path(tmpdir) / 'test-registry.json'
+            resolved = str(Path(tmpdir).resolve() / 'oldproj')
+            registry_file.write_text(json.dumps({"oldproj": resolved}))
+
+            pr = ProjectRegistry(registry_file=str(registry_file))
+            assert pr.is_path_registered(resolved) is True
+            assert pr.is_path_registered("/other/path") is False
+
+
+def test_auto_register_on_open():
+    """Test that main() auto-registers a project with .jot.json not in registry"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        project_dir = tmpdir / 'newproject'
+        project_dir.mkdir()
+        (project_dir / '.jot.json').write_text('{"tasks": [], "archived": []}')
+
+        registry_file = tmpdir / 'test-registry.json'
+        registry_file.write_text('{}')
+
+        pr = ProjectRegistry(registry_file=str(registry_file))
+        assert pr.is_path_registered(str(project_dir)) is False
+
+        # Simulate the auto-registration logic from main()
+        target_dir = project_dir
+        is_global = False
+        if (
+            target_dir
+            and not is_global
+            and (target_dir / '.jot.json').exists()
+            and not pr.is_path_registered(target_dir)
+        ):
+            pr.register_project(target_dir.name, str(target_dir))
+
+        assert pr.is_path_registered(str(project_dir)) is True
+        assert pr.get_project_path("newproject") is not None
+
+
+def test_auto_register_skips_global():
+    """Test that auto-registration is skipped for global categories"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        registry_file = tmpdir / 'test-registry.json'
+        registry_file.write_text('{}')
+
+        pr = ProjectRegistry(registry_file=str(registry_file))
+
+        # is_global=True should skip registration
+        target_dir = tmpdir
+        is_global = True
+        if (
+            target_dir
+            and not is_global
+            and (target_dir / '.jot.json').exists()
+            and not pr.is_path_registered(target_dir)
+        ):
+            pr.register_project(target_dir.name, str(target_dir))
+
+        assert pr.is_path_registered(str(tmpdir)) is False
+
+
+def test_auto_register_skips_already_registered():
+    """Test that auto-registration is skipped if already registered"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        project_dir = tmpdir / 'existing'
+        project_dir.mkdir()
+        (project_dir / '.jot.json').write_text('{"tasks": [], "archived": []}')
+
+        registry_file = tmpdir / 'test-registry.json'
+        registry_file.write_text('{}')
+
+        pr = ProjectRegistry(registry_file=str(registry_file))
+        pr.register_project("existing", str(project_dir))
+
+        # Should not re-register (usage_count should stay 0)
+        target_dir = project_dir
+        is_global = False
+        if (
+            target_dir
+            and not is_global
+            and (target_dir / '.jot.json').exists()
+            and not pr.is_path_registered(target_dir)
+        ):
+            pr.register_project(target_dir.name, str(target_dir))
+
+        items = pr.list_projects_by_usage()
+        assert len(items) == 1
+
 
 def test_id_uniqueness_stress_test():
     """Stress test: Add, delete, add many times"""
@@ -3053,6 +3157,7 @@ class TestImportIntegrity:
     def test_task_manager_imports(self):
         """TaskManager module has all required imports (sys, re, uuid, etc.)"""
         import jot.core.task_manager as mod
+
         assert hasattr(mod, 'sys')
         assert hasattr(mod, 're')
         assert hasattr(mod, 'json')
@@ -3064,6 +3169,7 @@ class TestImportIntegrity:
         import jot.commands._web_clipboard_mixin as web_mod
         import jot.commands._ai_analysis_mixin as ai_mod
         import jot.commands._core_mixin as core_mod
+
         assert hasattr(web_mod, 'webbrowser')
         assert hasattr(web_mod, 'urllib')
         assert hasattr(ai_mod, 'uuid')
@@ -3072,12 +3178,14 @@ class TestImportIntegrity:
     def test_keyword_handler_imports(self):
         """KeywordHandler mixin modules have all required imports"""
         import jot.integrations.keywords._handlers_mixin as mod
+
         assert hasattr(mod, 'json')
         assert hasattr(mod, 'subprocess')
 
     def test_category_templates_importable(self):
         """CategoryTemplates class exists and is importable"""
         from jot.categories.templates import CategoryTemplates
+
         ct = CategoryTemplates()
         templates = ct.list_templates()
         assert len(templates) > 0
@@ -3086,6 +3194,7 @@ class TestImportIntegrity:
     def test_category_templates_apply(self):
         """CategoryTemplates can apply a template"""
         from jot.categories.templates import CategoryTemplates
+
         with tempfile.TemporaryDirectory() as tmpdir:
             ct = CategoryTemplates(project_dir=tmpdir)
             success, msg = ct.apply_template('software-dev')
@@ -3095,6 +3204,7 @@ class TestImportIntegrity:
     def test_category_templates_invalid(self):
         """CategoryTemplates rejects invalid template name"""
         from jot.categories.templates import CategoryTemplates
+
         ct = CategoryTemplates()
         success, msg = ct.apply_template('nonexistent-template')
         assert success is False
@@ -3102,14 +3212,18 @@ class TestImportIntegrity:
     def test_webbrowser_open_url_no_crash(self):
         """open_url method can be called without NameError"""
         from jot.commands.handler import CommandHandler
+
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
             jot_file = tmpdir / '.jot.json'
-            jot_file.write_text(json.dumps({
-                'tasks': [{'id': 1, 'text': 'no url here', 'done': False,
-                           'current': True}],
-                'archived': [],
-            }))
+            jot_file.write_text(
+                json.dumps(
+                    {
+                        'tasks': [{'id': 1, 'text': 'no url here', 'done': False, 'current': True}],
+                        'archived': [],
+                    }
+                )
+            )
             tm = TaskManager(directory=tmpdir)
             ch = CommandHandler(tm)
             # Should print "No URLs found" but NOT raise NameError
@@ -3119,6 +3233,7 @@ class TestImportIntegrity:
     def test_web_search_no_crash(self):
         """web_search method doesn't crash on urllib.parse import"""
         import jot.commands._web_clipboard_mixin as mod
+
         # Verify urllib.parse is available in the module
         assert hasattr(mod.urllib, 'parse')
         assert callable(mod.urllib.parse.quote_plus)
@@ -3126,17 +3241,20 @@ class TestImportIntegrity:
     def test_uuid_available_in_handler(self):
         """uuid module available for session tracking in analysis mixin"""
         import jot.commands._ai_analysis_mixin as mod
+
         assert callable(mod.uuid.uuid4)
         assert callable(mod.uuid.uuid5)
 
     def test_sys_stderr_in_task_manager(self):
         """sys.stderr available for warning output in TaskManager"""
         import jot.core.task_manager as mod
+
         assert hasattr(mod.sys, 'stderr')
 
     def test_keyword_all_broadcast(self):
         """'all:' keyword returns __all__ sentinel for broadcast"""
         from jot.integrations.keywords.handler import KeywordHandler
+
         kh = KeywordHandler()
         keyword, text, project = kh.extract_keyword('all: Test task')
         assert keyword is None
@@ -3148,20 +3266,29 @@ class TestImportIntegrity:
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
             jot_file = tmpdir / '.jot.json'
-            jot_file.write_text(json.dumps({
-                'tasks': [], 'archived': [],
-            }))
+            jot_file.write_text(
+                json.dumps(
+                    {
+                        'tasks': [],
+                        'archived': [],
+                    }
+                )
+            )
             ids_file = tmpdir / '.jot.ids.json'
-            ids_file.write_text(json.dumps({
-                'next_id': 1, 'allocated': [],
-            }))
+            ids_file.write_text(
+                json.dumps(
+                    {
+                        'next_id': 1,
+                        'allocated': [],
+                    }
+                )
+            )
 
             tm = TaskManager(directory=tmpdir)
             tm.add_task('Parent task')
             parent_id = tm.tasks[0]['id']
 
-            tm.set_task_notes(parent_id,
-                              '- [ ] sub one\n- [ ] sub two\n- [X] sub done')
+            tm.set_task_notes(parent_id, '- [ ] sub one\n- [ ] sub two\n- [X] sub done')
 
             # First sync — checked item skipped (#578)
             r1 = tm.sync_subtasks_from_notes(parent_id)
@@ -3180,13 +3307,23 @@ class TestImportIntegrity:
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
             jot_file = tmpdir / '.jot.json'
-            jot_file.write_text(json.dumps({
-                'tasks': [], 'archived': [],
-            }))
+            jot_file.write_text(
+                json.dumps(
+                    {
+                        'tasks': [],
+                        'archived': [],
+                    }
+                )
+            )
             ids_file = tmpdir / '.jot.ids.json'
-            ids_file.write_text(json.dumps({
-                'next_id': 1, 'allocated': [],
-            }))
+            ids_file.write_text(
+                json.dumps(
+                    {
+                        'next_id': 1,
+                        'allocated': [],
+                    }
+                )
+            )
 
             tm = TaskManager(directory=tmpdir)
             tm.add_task('Parent')
@@ -3218,17 +3355,14 @@ class TestImportIntegrity:
             proj_b.mkdir()
 
             for proj in [proj_a, proj_b]:
-                (proj / '.jot.json').write_text(
-                    json.dumps({'tasks': [], 'archived': []}))
-                (proj / '.jot.ids.json').write_text(
-                    json.dumps({'next_id': 1, 'allocated': []}))
+                (proj / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+                (proj / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
 
             # Pre-create empty registry to prevent auto-discover
             # from loading real ~/projects into the test registry
             reg_file = tmpdir / '.jot-projects.json'
             reg_file.write_text('{}')
-            registry = ProjectRegistry(
-                registry_file=str(reg_file))
+            registry = ProjectRegistry(registry_file=str(reg_file))
             registry.register_project('proj-a', str(proj_a))
             registry.register_project('proj-b', str(proj_b))
 
@@ -3247,8 +3381,10 @@ class TestImportIntegrity:
         """CLI --all broadcast requires y confirmation, N cancels"""
         from unittest.mock import patch
         import importlib.util
+
         spec = importlib.util.spec_from_file_location(
-            "jot_main", str(Path(__file__).parent.parent / "jot.py"))
+            "jot_main", str(Path(__file__).parent.parent / "jot.py")
+        )
         jot_main = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(jot_main)
         _handle_initial_task = jot_main._handle_initial_task
@@ -3257,10 +3393,8 @@ class TestImportIntegrity:
             tmpdir = Path(tmpdir)
             proj = tmpdir / 'proj'
             proj.mkdir()
-            (proj / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (proj / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (proj / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (proj / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
 
             reg_file = tmpdir / '.jot-projects.json'
             reg_file.write_text('{}')
@@ -3271,9 +3405,7 @@ class TestImportIntegrity:
 
             # Declining should NOT add any tasks
             with patch('builtins.input', return_value='n'):
-                _handle_initial_task(
-                    tm, 'test task', True,
-                    registry, None, False, None)
+                _handle_initial_task(tm, 'test task', True, registry, None, False, None)
 
             data = json.loads((proj / '.jot.json').read_text())
             assert len(data['tasks']) == 0
@@ -3282,10 +3414,8 @@ class TestImportIntegrity:
         """Normal add_task returns an integer task ID"""
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
-            (tmpdir / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (tmpdir / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (tmpdir / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (tmpdir / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
             tm = TaskManager(directory=tmpdir)
             result = tm.add_task('normal task')
             assert isinstance(result, int)
@@ -3294,14 +3424,11 @@ class TestImportIntegrity:
         """add_task with 'all:' prefix returns broadcast metadata"""
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
-            (tmpdir / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (tmpdir / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (tmpdir / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (tmpdir / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
             reg_file = tmpdir / '.jot-projects.json'
             reg_file.write_text('{}')
-            registry = ProjectRegistry(
-                registry_file=str(reg_file))
+            registry = ProjectRegistry(registry_file=str(reg_file))
             registry.register_project('proj-a', str(tmpdir))
             tm = TaskManager(directory=tmpdir, project_registry=registry)
             result = tm.add_task('all: broadcast task')
@@ -3318,18 +3445,13 @@ class TestImportIntegrity:
             tmpdir = Path(tmpdir)
             proj_a = tmpdir / 'proj-a'
             proj_a.mkdir()
-            (proj_a / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (proj_a / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
-            (tmpdir / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (tmpdir / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (proj_a / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (proj_a / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
+            (tmpdir / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (tmpdir / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
             reg_file = tmpdir / '.jot-projects.json'
             reg_file.write_text('{}')
-            registry = ProjectRegistry(
-                registry_file=str(reg_file))
+            registry = ProjectRegistry(registry_file=str(reg_file))
             registry.register_project('proj-a', str(proj_a))
             tm = TaskManager(directory=tmpdir, project_registry=registry)
             result = tm.add_task('proj-a: routed task')
@@ -3347,14 +3469,10 @@ class TestImportIntegrity:
             proj_a.mkdir()
             proj_b.mkdir()
             for proj in [proj_a, proj_b]:
-                (proj / '.jot.json').write_text(
-                    json.dumps({'tasks': [], 'archived': []}))
-                (proj / '.jot.ids.json').write_text(
-                    json.dumps({'next_id': 1, 'allocated': []}))
-            (tmpdir / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (tmpdir / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+                (proj / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+                (proj / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
+            (tmpdir / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (tmpdir / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
             # Pre-create registry file to prevent auto-discover
             reg_file = tmpdir / '.jot-projects.json'
             reg_file.write_text('{}')
@@ -3362,21 +3480,17 @@ class TestImportIntegrity:
             registry.register_project('proj-a', str(proj_a))
             registry.register_project('proj-b', str(proj_b))
             tm = TaskManager(directory=tmpdir, project_registry=registry)
-            count = tm._route_to_project(
-                'test task', '__all__', 'none', 'todo', None, None)
+            count = tm._route_to_project('test task', '__all__', 'none', 'todo', None, None)
             assert count == 2
 
-
     def test_broadcast_deduplicates_symlinked_projects(self):
         """Symlinked projects that resolve to the same path get one write, not two"""
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)
             real_proj = tmpdir / 'real-proj'
             real_proj.mkdir()
-            (real_proj / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (real_proj / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (real_proj / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (real_proj / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
 
             # Create a symlink to the same directory
             symlink_proj = tmpdir / 'symlink-proj'
@@ -3389,14 +3503,11 @@ class TestImportIntegrity:
             registry.projects['symlink-proj'] = str(symlink_proj)
             registry._save_registry()
 
-            (tmpdir / '.jot.json').write_text(
-                json.dumps({'tasks': [], 'archived': []}))
-            (tmpdir / '.jot.ids.json').write_text(
-                json.dumps({'next_id': 1, 'allocated': []}))
+            (tmpdir / '.jot.json').write_text(json.dumps({'tasks': [], 'archived': []}))
+            (tmpdir / '.jot.ids.json').write_text(json.dumps({'next_id': 1, 'allocated': []}))
             tm = TaskManager(directory=tmpdir, project_registry=registry)
 
-            count = tm._route_to_project(
-                'dedup test', '__all__', 'none', 'todo', None, None)
+            count = tm._route_to_project('dedup test', '__all__', 'none', 'todo', None, None)
             assert count == 1  # Only one write despite two registry entries
 
             data = json.loads((real_proj / '.jot.json').read_text())
@@ -3425,6 +3536,7 @@ class TestImportIntegrity:
 
             # Manually call _auto_discover with patched home
             from unittest.mock import patch
+
             with patch.object(Path, 'home', return_value=tmpdir):
                 registry.projects = {}
                 registry._auto_discover()
@@ -3438,6 +3550,7 @@ class TestExtractTimeTag:
 
     def test_time_tag_at_end(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("standup 0930")
         assert hour == 9
         assert minute == 30
@@ -3445,6 +3558,7 @@ class TestExtractTimeTag:
 
     def test_time_tag_at_start(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("0800 morning routine")
         assert hour == 8
         assert minute == 0
@@ -3452,6 +3566,7 @@ class TestExtractTimeTag:
 
     def test_time_tag_in_middle(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("do 1430 thing")
         assert hour == 14
         assert minute == 30
@@ -3459,6 +3574,7 @@ class TestExtractTimeTag:
 
     def test_no_time_tag(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("no time here")
         assert hour is None
         assert minute is None
@@ -3466,16 +3582,19 @@ class TestExtractTimeTag:
 
     def test_invalid_hour(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("meeting 2500")
         assert hour is None  # 25 > 23
 
     def test_invalid_minute(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("meeting 0961")
         assert hour is None  # 61 > 59
 
     def test_not_standalone(self):
         from jot.utils.date_utils import extract_time_tag
+
         hour, minute, cleaned = extract_time_tag("task1430foo")
         assert hour is None  # Not space-delimited
 
@@ -3486,17 +3605,24 @@ class TestGcalImportTaskText:
     @staticmethod
     def _make_event(summary, all_day=False, start_hour=None, end_hour=None):
         from datetime import datetime, timezone
+
         date = datetime(2026, 2, 27).date()
         if all_day:
-            return {'summary': summary, 'start': None, 'end': None,
-                    'all_day': True, 'date': date, 'description': ''}
+            return {
+                'summary': summary,
+                'start': None,
+                'end': None,
+                'all_day': True,
+                'date': date,
+                'description': '',
+            }
         return {
             'summary': summary,
-            'start': datetime(2026, 2, 27, start_hour or 9, 0,
-                              tzinfo=timezone.utc),
-            'end': datetime(2026, 2, 27, end_hour or 10, 0,
-                            tzinfo=timezone.utc),
-            'all_day': False, 'date': date, 'description': '',
+            'start': datetime(2026, 2, 27, start_hour or 9, 0, tzinfo=timezone.utc),
+            'end': datetime(2026, 2, 27, end_hour or 10, 0, tzinfo=timezone.utc),
+            'all_day': False,
+            'date': date,
+            'description': '',
         }
 
     def test_timed_event_uses_calendar_icon_not_time(self, tmp_path):
@@ -3510,10 +3636,8 @@ class TestGcalImportTaskText:
         handler = type('Handler', (GcalMixin,), {})()
         handler.task_manager = tm
 
-        with patch('jot.commands._gcal_mixin.multiselect_picker',
-                   return_value=[ev]):
-            handler._display_and_import_events(
-                [ev], 'today', 'default', 'today')
+        with patch('jot.commands._gcal_mixin.multiselect_picker', return_value=[ev]):
+            handler._display_and_import_events([ev], 'today', 'default', 'today')
 
         assert len(tm.tasks) == 1
         assert tm.tasks[0]['text'] == '📆 Morning Standup'
@@ -3530,10 +3654,8 @@ class TestGcalImportTaskText:
         handler = type('Handler', (GcalMixin,), {})()
         handler.task_manager = tm
 
-        with patch('jot.commands._gcal_mixin.multiselect_picker',
-                   return_value=[ev]):
-            handler._display_and_import_events(
-                [ev], 'today', 'default', 'today')
+        with patch('jot.commands._gcal_mixin.multiselect_picker', return_value=[ev]):
+            handler._display_and_import_events([ev], 'today', 'default', 'today')
 
         assert len(tm.tasks) == 1
         assert tm.tasks[0]['text'] == '📅 Team Offsite'
@@ -3549,10 +3671,8 @@ class TestGcalImportTaskText:
         handler = type('Handler', (GcalMixin,), {})()
         handler.task_manager = tm
 
-        with patch('jot.commands._gcal_mixin.multiselect_picker',
-                   return_value=[]):
-            handler._display_and_import_events(
-                [ev], 'today', 'default', 'today')
+        with patch('jot.commands._gcal_mixin.multiselect_picker', return_value=[]):
+            handler._display_and_import_events([ev], 'today', 'default', 'today')
 
         assert len(tm.tasks) == 0
 
@@ -3569,10 +3689,8 @@ class TestGcalImportTaskText:
         handler = type('Handler', (GcalMixin,), {})()
         handler.task_manager = tm
 
-        with patch('jot.commands._gcal_mixin.multiselect_picker',
-                   return_value=[ev1, ev3]):
-            handler._display_and_import_events(
-                [ev1, ev2, ev3], 'today', 'default', 'today')
+        with patch('jot.commands._gcal_mixin.multiselect_picker', return_value=[ev1, ev3]):
+            handler._display_and_import_events([ev1, ev2, ev3], 'today', 'default', 'today')
 
         assert len(tm.tasks) == 2
         texts = [t['text'] for t in tm.tasks]
@@ -3596,10 +3714,8 @@ class TestGcalImportTaskText:
 
         today = datetime.now().date()
         assert GcalMixin._event_day_annotation(today, today) == "Today"
-        assert GcalMixin._event_day_annotation(
-            today + timedelta(days=1), today) == "Tomorrow"
-        assert GcalMixin._event_day_annotation(
-            today - timedelta(days=1), today) == "Yesterday"
+        assert GcalMixin._event_day_annotation(today + timedelta(days=1), today) == "Tomorrow"
+        assert GcalMixin._event_day_annotation(today - timedelta(days=1), today) == "Yesterday"
 
 
 class TestMultiselectPicker:
@@ -3610,8 +3726,7 @@ class TestMultiselectPicker:
         from unittest.mock import patch
         from jot.ui.picker import PickerItem, multiselect_picker
 
-        items = [PickerItem(value='a', label='Alpha'),
-                 PickerItem(value='b', label='Beta')]
+        items = [PickerItem(value='a', label='Alpha'), PickerItem(value='b', label='Beta')]
 
         with patch('jot.ui.picker.get_key', return_value='\r'):
             result = multiselect_picker(items)
@@ -3635,8 +3750,7 @@ class TestMultiselectPicker:
         from unittest.mock import patch
         from jot.ui.picker import PickerItem, multiselect_picker
 
-        items = [PickerItem(value='a', label='Alpha'),
-                 PickerItem(value='b', label='Beta')]
+        items = [PickerItem(value='a', label='Alpha'), PickerItem(value='b', label='Beta')]
 
         keys = iter([' ', '\r'])  # Space deselects item 0, Enter confirms
         with patch('jot.ui.picker.get_key', side_effect=keys):
@@ -3647,6 +3761,7 @@ class TestMultiselectPicker:
     def test_empty_items_returns_empty(self):
         """Empty item list returns empty immediately."""
         from jot.ui.picker import multiselect_picker
+
         assert multiselect_picker([]) == []