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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.5.4
+Version: 0.5.5
 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.4 → jott_cli-0.5.5}/jot/__init__.py

@@ -7,7 +7,7 @@ import importlib.util
 import os
 from pathlib import Path
 
-__version__ = "0.5.4"
+__version__ = "0.5.5"
 
 # 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.4 → jott_cli-0.5.5}/jot/_app_navigation_mixin.py

@@ -38,12 +38,11 @@ class AppNavigationMixin:
         return False
 
     def _handle_toggle(self, key):
-        """Process shared toggle keys A/O/Y/F.  Returns True if
+        """Process shared toggle keys O/Y/F.  Returns True if
         the key was a toggle key."""
         st = self.state
 
         toggle_map = {
-            'A': ('show_archived', 'archived tasks'),
             'O': ('sort_by_day', None),
             'Y': ('show_today_only', None),
             'F': ('show_notes_inline', 'inline notes'),

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

@@ -153,7 +153,7 @@ class DispatchMixin:
                 time.sleep(0.3)
             return
 
-        if key in ('A', 'O', 'Y'):
+        if key in ('O', 'Y'):
             self._handle_toggle(key)
             return
 
@@ -317,6 +317,13 @@ class DispatchMixin:
             self.command_handler.web_search()
             st.input_buffer = ""
             return
+        if second == 'a':
+            st.show_archived = not st.show_archived
+            status = "Showing" if st.show_archived else "Hiding"
+            print(f"\n{CYAN}\u2713 {status} archived tasks{RESET}")
+            time.sleep(0.3)
+            st.input_buffer = ""
+            return
         # Not a chord — treat '.' as normal input
         st.input_buffer += '.'
         if second and second != '.':

{jott_cli-0.5.4 → jott_cli-0.5.5}/jot/commands/_transfer_mixin.py

@@ -43,6 +43,58 @@ class TransferMixin:
         result = fuzzy_picker(items, prompt=prompt_text)
         return result.value
 
+    def _transfer_task_to_target(self, task, target_tm, labels=None):
+        """Add task to target_tm preserving metadata. Returns new task ID."""
+        new_id = target_tm.add_task(
+            task['text'],
+            priority=task.get('priority', 'none'),
+            status=task.get('status', 'todo'),
+            labels=labels if labels is not None else [],
+            effort=task.get('effort', None),
+        )
+        new_task = target_tm.tasks[-1]
+        for key in ('notes', 'agent_task', 'keyword', 'day', 'created_at'):
+            if task.get(key) is not None:
+                new_task[key] = task[key]
+        return new_id
+
+    def _transfer_descendants(self, parent_task, target_tm, id_map):
+        """Transfer all descendants of parent_task to target_tm.
+
+        Walks descendants in BFS order, remapping parent:{old} labels to
+        parent:{new} using the id_map. Updates id_map in place.
+        """
+        descendants = self.task_manager._get_descendants(parent_task['id'])
+        for child in descendants:
+            old_labels = child.get('labels', [])
+            new_labels = []
+            for label in old_labels:
+                if label.startswith('parent:'):
+                    old_pid = int(label.split(':')[1])
+                    new_pid = id_map.get(old_pid, old_pid)
+                    new_labels.append(f"parent:{new_pid}")
+                else:
+                    new_labels.append(label)
+            new_id = self._transfer_task_to_target(child, target_tm, labels=new_labels)
+            id_map[child['id']] = new_id
+        return descendants
+
+    def _remove_tasks_from_source(self, parent_id, descendants):
+        """Remove descendants first, then parent, from source task manager.
+
+        Removes children before parent so _unlink_children on the parent
+        doesn't redundantly strip labels from already-present tasks.
+        """
+        for child in reversed(descendants):
+            self.task_manager.remove_task(child['id'])
+        self.task_manager.remove_task(parent_id)
+
+    def _confirm_subtask_action(self, action, count, target_name):
+        """Prompt user to confirm moving/copying subtasks. Returns True if confirmed."""
+        prompt = f"{action} task + {count} subtask{'s' if count != 1 else ''} to {target_name}? (y/N): "
+        response = input(prompt).strip().lower()
+        return response == 'y'
+
     def copy_task_to_project(self):
         """Copy current task to a different project (keeps original)"""
         if not self.registry:
@@ -55,15 +107,20 @@ class TransferMixin:
             return True
 
         task_text = current_task['text']
+        descendants = self.task_manager._get_descendants(current_task['id'])
 
         target_project = self._pick_project_fuzzy(f"Copy '{task_text}' to:")
         if not target_project:
             print("\n✗ Cancelled")
             return True
 
+        if descendants:
+            if not self._confirm_subtask_action("Copy", len(descendants), target_project):
+                print("\n✗ Cancelled")
+                return True
+
         target_path = self.registry.get_project_path(target_project)
 
-        # Check if destination has the same category
         current_category = self.task_manager.category
         target_category = None
         category_preserved = False
@@ -77,36 +134,32 @@ class TransferMixin:
         target_tm = TaskManager(
             directory=target_path, category=target_category, project_registry=self.registry
         )
-        target_tm.add_task(
-            task_text,
-            priority=current_task.get('priority', 'none'),
-            status=current_task.get('status', 'todo'),
-            labels=[l for l in current_task.get('labels', [])
-                    if not l.startswith('parent:')],
-            effort=current_task.get('effort', None),
+
+        # Copy parent task (strip parent: labels since parent is top-level in dest)
+        parent_labels = [l for l in current_task.get('labels', [])
+                         if not l.startswith('parent:')]
+        new_parent_id = self._transfer_task_to_target(
+            current_task, target_tm, labels=parent_labels
         )
 
-        # Preserve additional metadata on the new task
-        new_task = target_tm.tasks[-1]
-        new_task['notes'] = current_task.get('notes', '')
-        new_task['agent_task'] = current_task.get('agent_task', False)
-        new_task['keyword'] = current_task.get('keyword', None)
-        new_task['day'] = current_task.get('day', None)
-        if current_task.get('created_at'):
-            new_task['created_at'] = current_task['created_at']
+        # Copy descendants with remapped parent labels
+        if descendants:
+            id_map = {current_task['id']: new_parent_id}
+            self._transfer_descendants(current_task, target_tm, id_map)
 
         target_tm._save_tasks()
         self.registry.record_usage(target_project)
 
+        count_msg = f" + {len(descendants)} subtask{'s' if len(descendants) != 1 else ''}" if descendants else ""
         if category_preserved:
-            print(f"✓ Copied task to {target_project} (kept in '{current_category}' category)")
+            print(f"✓ Copied task{count_msg} to {target_project} (kept in '{current_category}' category)")
         elif current_category:
             print(
-                f"✓ Copied task to {target_project} "
+                f"✓ Copied task{count_msg} to {target_project} "
                 f"(category '{current_category}' not available, added to default)"
             )
         else:
-            print(f"✓ Copied task to {target_project}")
+            print(f"✓ Copied task{count_msg} to {target_project}")
         return True
 
     def move_task_to_project(self):
@@ -122,12 +175,18 @@ class TransferMixin:
 
         task_id = current_task['id']
         task_text = current_task['text']
+        descendants = self.task_manager._get_descendants(task_id)
 
         target_project = self._pick_project_fuzzy(f"Move '{task_text}' to:")
         if not target_project:
             print("\n✗ Cancelled")
             return True
 
+        if descendants:
+            if not self._confirm_subtask_action("Move", len(descendants), target_project):
+                print("\n✗ Cancelled")
+                return True
+
         target_path = self.registry.get_project_path(target_project)
 
         current_category = self.task_manager.category
@@ -143,36 +202,35 @@ class TransferMixin:
         target_tm = TaskManager(
             directory=target_path, category=target_category, project_registry=self.registry
         )
-        target_tm.add_task(
-            task_text,
-            priority=current_task.get('priority', 'none'),
-            status=current_task.get('status', 'todo'),
-            labels=[l for l in current_task.get('labels', [])
-                    if not l.startswith('parent:')],
-            effort=current_task.get('effort', None),
+
+        # Move parent task
+        parent_labels = [l for l in current_task.get('labels', [])
+                         if not l.startswith('parent:')]
+        new_parent_id = self._transfer_task_to_target(
+            current_task, target_tm, labels=parent_labels
         )
 
-        new_task = target_tm.tasks[-1]
-        new_task['notes'] = current_task.get('notes', '')
-        new_task['agent_task'] = current_task.get('agent_task', False)
-        new_task['keyword'] = current_task.get('keyword', None)
-        new_task['day'] = current_task.get('day', None)
-        if current_task.get('created_at'):
-            new_task['created_at'] = current_task['created_at']
+        # Move descendants with remapped parent labels
+        if descendants:
+            id_map = {task_id: new_parent_id}
+            self._transfer_descendants(current_task, target_tm, id_map)
 
         target_tm._save_tasks()
-        self.task_manager.remove_task(task_id)
+
+        # Remove from source: descendants first, then parent
+        self._remove_tasks_from_source(task_id, descendants)
         self.registry.record_usage(target_project)
 
+        count_msg = f" + {len(descendants)} subtask{'s' if len(descendants) != 1 else ''}" if descendants else ""
         if category_preserved:
-            print(f"✓ Moved task to {target_project} (kept in '{current_category}' category)")
+            print(f"✓ Moved task{count_msg} to {target_project} (kept in '{current_category}' category)")
         elif current_category:
             print(
-                f"✓ Moved task to {target_project} "
+                f"✓ Moved task{count_msg} to {target_project} "
                 f"(category '{current_category}' not available, added to default)"
             )
         else:
-            print(f"✓ Moved task to {target_project}")
+            print(f"✓ Moved task{count_msg} to {target_project}")
         return True
 
     def transfer_task_to_category(self):
@@ -184,7 +242,7 @@ class TransferMixin:
 
         task_text = current_task['text']
         task_id = current_task['id']
-        task_done = current_task.get('done', False)
+        descendants = self.task_manager._get_descendants(task_id)
 
         project_dir = (
             self.task_manager.project_dir if not self.task_manager.is_global else Path.cwd()
@@ -235,6 +293,12 @@ class TransferMixin:
             return True
 
         selected_category, selected_is_global = result.value
+        dest_name = selected_category or 'default'
+
+        if descendants:
+            if not self._confirm_subtask_action("Transfer", len(descendants), dest_name):
+                print("\n✗ Cancelled")
+                return True
 
         if selected_is_global:
             dest_tm = TaskManager(
@@ -248,18 +312,28 @@ class TransferMixin:
                 project_registry=self.registry,
             )
 
-        dest_tm.add_task(task_text)
-        if task_done:
-            new_task_id = dest_tm.tasks[-1]['id']
-            dest_tm.set_task_status(new_task_id, 'done')
+        # Transfer parent task with full metadata
+        parent_labels = [l for l in current_task.get('labels', [])
+                         if not l.startswith('parent:')]
+        new_parent_id = self._transfer_task_to_target(
+            current_task, dest_tm, labels=parent_labels
+        )
 
-        self.task_manager.remove_task(task_id)
+        # Transfer descendants with remapped parent labels
+        if descendants:
+            id_map = {task_id: new_parent_id}
+            self._transfer_descendants(current_task, dest_tm, id_map)
 
-        dest_name = selected_category or 'default'
+        dest_tm._save_tasks()
+
+        # Remove from source: descendants first, then parent
+        self._remove_tasks_from_source(task_id, descendants)
+
+        count_msg = f" + {len(descendants)} subtask{'s' if len(descendants) != 1 else ''}" if descendants else ""
         if selected_is_global:
-            print(f"✓ Transferred task to global:{dest_name}")
+            print(f"✓ Transferred task{count_msg} to global:{dest_name}")
         else:
-            print(f"✓ Transferred task to {dest_name}")
+            print(f"✓ Transferred task{count_msg} to {dest_name}")
 
         print("\nPress Enter to continue...", end='', flush=True)
         input()

{jott_cli-0.5.4 → jott_cli-0.5.5}/jot/core/_subtask_mixin.py

@@ -55,6 +55,21 @@ def _finalize_nested(item, nested_lines):
 class SubtaskMixin:
     """Sync subtasks from task notes checklists."""
 
+    def _get_descendants(self, task_id):
+        """Return all descendant tasks (BFS) for a parent task."""
+        descendants = []
+        queue = [task_id]
+        visited = {task_id}
+        while queue:
+            pid = queue.pop(0)
+            parent_label = f"parent:{pid}"
+            for task in self.tasks:
+                if parent_label in task.get('labels', []) and task['id'] not in visited:
+                    visited.add(task['id'])
+                    descendants.append(task)
+                    queue.append(task['id'])
+        return descendants
+
     def sync_subtasks_from_notes(self, task_id):
         """Parse checklist items from task notes and sync as subtasks.
 

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

@@ -21,7 +21,7 @@ def display_categorized_shortcuts():
             ("d", "Delete task"),
             ("t", "Toggle task done"),
             ("a", "Archive task"),
-            ("Shift+A", "Toggle archive view"),
+            (".a", "Toggle archive view"),
             ("m", "Move to different category"),
             ("Shift+M", "Move task to another project"),
             ("Ctrl+K", "Copy task to another project"),
@@ -97,7 +97,7 @@ def display_help():
     """Display comprehensive help information."""
     help_text = f"""
 {BOLD}Jott - Simple Interactive Task List{RESET}
-{DIM}Version 0.5.2{RESET}
+{DIM}Version 0.5.5{RESET}
 
 {BOLD}BASIC USAGE:{RESET}
   jott                      Start interactive task manager (current project)
@@ -129,7 +129,7 @@ def display_help():
   {CYAN}d{RESET}                Delete selected task
   {CYAN}t{RESET}                Toggle task done/undone
   {CYAN}a{RESET}                Archive task (mark as done/canceled)
-  {CYAN}Shift+A{RESET}          Toggle archive view
+  {CYAN}.a{RESET}               Toggle archive view
   {CYAN}m{RESET}                Move task to different category
   {CYAN}Shift+M{RESET}          Move task to another project
   {CYAN}Ctrl+K{RESET}           Copy task to another project

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.5.4
+Version: 0.5.5
 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.4 → jott_cli-0.5.5}/jott_cli.egg-info/SOURCES.txt

@@ -92,4 +92,5 @@ tests/test_picker.py
 tests/test_styles.py
 tests/test_subtask_notes.py
 tests/test_terminal_wrap.py
-tests/test_today_filter.py
+tests/test_today_filter.py
+tests/test_transfer_subtasks.py

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

@@ -7,7 +7,7 @@ include = ["jot", "jot.*"]
 
 [project]
 name = "jott-cli"
-version = "0.5.4"
+version = "0.5.5"
 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.4 → jott_cli-0.5.5}/tests/test_jot.py

@@ -730,6 +730,20 @@ class TestProjectRegistry:
             assert pr.is_path_registered("/other/path") is False
 
 
+def _simulate_auto_register(proj_dir, registry, is_global=False):
+    """Simulate the auto-registration logic from main().
+
+    Uses proj_dir (task_manager.project_dir) which is always set,
+    regardless of whether target_dir was passed on the command line.
+    """
+    if (
+        not is_global
+        and (proj_dir / '.jot.json').exists()
+        and not registry.is_path_registered(proj_dir)
+    ):
+        registry.register_project(proj_dir.name, str(proj_dir))
+
+
 def test_auto_register_on_open():
     """Test that main() auto-registers a project with .jot.json not in registry"""
     with tempfile.TemporaryDirectory() as tmpdir:
@@ -744,40 +758,45 @@ def test_auto_register_on_open():
         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))
+        _simulate_auto_register(project_dir, pr)
 
         assert pr.is_path_registered(str(project_dir)) is True
         assert pr.get_project_path("newproject") is not None
 
 
+def test_auto_register_when_no_target_dir():
+    """Test auto-register works when user runs jott from inside a project (no target_dir)."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        project_dir = tmpdir / 'myproject'
+        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: user cd'd into project_dir and ran `jott` with no args.
+        # target_dir would be None, but task_manager.project_dir = cwd = project_dir
+        _simulate_auto_register(project_dir, pr)
+
+        assert pr.is_path_registered(str(project_dir)) is True
+        assert pr.get_project_path("myproject") 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)
+        (tmpdir / '.jot.json').write_text('{"tasks": [], "archived": []}')
         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))
+        _simulate_auto_register(tmpdir, pr, is_global=True)
 
         assert pr.is_path_registered(str(tmpdir)) is False
 
@@ -796,16 +815,7 @@ def test_auto_register_skips_already_registered():
         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))
+        _simulate_auto_register(project_dir, pr)
 
         items = pr.list_projects_by_usage()
         assert len(items) == 1

jott_cli-0.5.5/tests/test_transfer_subtasks.py

@@ -0,0 +1,381 @@
+"""Tests for subtask transfer — move/copy/transfer with descendants (#634)."""
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from jot.core.task_manager import TaskManager
+
+
+def _make_tm(tmpdir):
+    """Create a TaskManager in a temporary directory."""
+    jot_file = tmpdir / '.jot.json'
+    jot_file.write_text(json.dumps({'tasks': [], 'archived': []}))
+    ids_file = tmpdir / '.jot.ids.json'
+    ids_file.write_text(json.dumps({'next_id': 1, 'allocated': []}))
+    return TaskManager(directory=tmpdir)
+
+
+class TestGetDescendants:
+    """Tests for SubtaskMixin._get_descendants()."""
+
+    def test_no_children(self):
+        """Leaf task returns empty list."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tm = _make_tm(Path(tmpdir))
+            tm.add_task('Parent')
+            tm.add_task('Unrelated')
+            pid = tm.tasks[0]['id']
+            assert tm._get_descendants(pid) == []
+
+    def test_direct_children(self):
+        """Returns direct children of parent."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tm = _make_tm(Path(tmpdir))
+            tm.add_task('Parent')
+            pid = tm.tasks[0]['id']
+            tm.add_task('Child 1', labels=[f'parent:{pid}'])
+            tm.add_task('Child 2', labels=[f'parent:{pid}'])
+
+            descendants = tm._get_descendants(pid)
+            texts = [d['text'] for d in descendants]
+            assert texts == ['Child 1', 'Child 2']
+
+    def test_grandchildren(self):
+        """Returns children and grandchildren in BFS order."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tm = _make_tm(Path(tmpdir))
+            tm.add_task('Root')
+            root_id = tm.tasks[0]['id']
+            tm.add_task('Child', labels=[f'parent:{root_id}'])
+            child_id = tm.tasks[1]['id']
+            tm.add_task('Grandchild', labels=[f'parent:{child_id}'])
+
+            descendants = tm._get_descendants(root_id)
+            texts = [d['text'] for d in descendants]
+            assert texts == ['Child', 'Grandchild']
+
+    def test_no_cycles(self):
+        """Visited set prevents infinite loops on cycle."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tm = _make_tm(Path(tmpdir))
+            tm.add_task('A')
+            tm.add_task('B')
+            a_id = tm.tasks[0]['id']
+            b_id = tm.tasks[1]['id']
+            # Create cycle: A -> B -> A
+            tm.tasks[1]['labels'] = [f'parent:{a_id}']
+            tm.tasks[0]['labels'] = [f'parent:{b_id}']
+            tm._save_tasks()
+
+            descendants = tm._get_descendants(a_id)
+            # Should find B but not loop back to A
+            assert len(descendants) == 1
+            assert descendants[0]['id'] == b_id
+
+    def test_nonexistent_parent(self):
+        """Returns empty for nonexistent parent ID."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tm = _make_tm(Path(tmpdir))
+            tm.add_task('Unrelated')
+            assert tm._get_descendants(999) == []
+
+
+class TestTransferTaskToTarget:
+    """Tests for TransferMixin._transfer_task_to_target()."""
+
+    def test_preserves_metadata(self):
+        """Transferred task preserves priority, status, effort, notes, etc."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Test task', priority='high', status='in_progress',
+                            effort='large')
+            task = tm_src.tasks[0]
+            task['notes'] = 'Important notes'
+            task['agent_task'] = True
+            task['keyword'] = 'bug'
+            task['day'] = '2026-03-31'
+            tm_src._save_tasks()
+
+            tm_tgt = _make_tm(target)
+
+            mixin = _make_transfer_mixin(tm_src)
+            new_id = mixin._transfer_task_to_target(task, tm_tgt, labels=['feature'])
+
+            new_task = tm_tgt.tasks[-1]
+            assert new_task['id'] == new_id
+            assert new_task['text'] == 'Test task'
+            assert new_task['priority'] == 'high'
+            assert new_task['status'] == 'in_progress'
+            assert new_task['effort'] == 'large'
+            assert new_task['notes'] == 'Important notes'
+            assert new_task['agent_task'] is True
+            assert new_task['keyword'] == 'bug'
+            assert new_task['day'] == '2026-03-31'
+            assert new_task['labels'] == ['feature']
+
+
+class TestMoveTaskWithSubtasks:
+    """Tests for moving parent + descendants to another project."""
+
+    def test_move_parent_with_children(self):
+        """Move parent + children, verify target has remapped parent labels."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Parent task')
+            pid = tm_src.tasks[0]['id']
+            tm_src.add_task('Child 1', labels=[f'parent:{pid}'])
+            tm_src.add_task('Child 2', labels=[f'parent:{pid}', 'feature'])
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            tm_tgt = _make_tm(target)
+            registry = _make_mock_registry(target)
+
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+
+            with patch.object(mixin, '_pick_project_fuzzy', return_value='target-proj'), \
+                 patch('jot.commands._transfer_mixin.TaskManager', return_value=tm_tgt), \
+                 patch('jot.commands._transfer_mixin.CategoryManager'), \
+                 patch('builtins.input', return_value='y'):
+                mixin.move_task_to_project()
+
+            # Source should have no tasks (all moved)
+            assert len(tm_src.tasks) == 0
+
+            # Target should have 3 tasks with correct parent links
+            assert len(tm_tgt.tasks) == 3
+            new_pid = tm_tgt.tasks[0]['id']
+            assert tm_tgt.tasks[0]['text'] == 'Parent task'
+
+            child1 = tm_tgt.tasks[1]
+            assert child1['text'] == 'Child 1'
+            assert f'parent:{new_pid}' in child1['labels']
+
+            child2 = tm_tgt.tasks[2]
+            assert child2['text'] == 'Child 2'
+            assert f'parent:{new_pid}' in child2['labels']
+            assert 'feature' in child2['labels']
+
+    def test_move_leaf_task_no_subtasks(self):
+        """Moving a leaf task (no children) works as before."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Leaf task')
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            tm_tgt = _make_tm(target)
+            registry = _make_mock_registry(target)
+
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+
+            with patch.object(mixin, '_pick_project_fuzzy', return_value='target-proj'), \
+                 patch('jot.commands._transfer_mixin.TaskManager', return_value=tm_tgt), \
+                 patch('jot.commands._transfer_mixin.CategoryManager'):
+                mixin.move_task_to_project()
+
+            assert len(tm_src.tasks) == 0
+            assert len(tm_tgt.tasks) == 1
+            assert tm_tgt.tasks[0]['text'] == 'Leaf task'
+
+    def test_move_with_grandchildren(self):
+        """Move parent with multi-level hierarchy, all IDs remapped correctly."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Root')
+            root_id = tm_src.tasks[0]['id']
+            tm_src.add_task('Child', labels=[f'parent:{root_id}'])
+            child_id = tm_src.tasks[1]['id']
+            tm_src.add_task('Grandchild', labels=[f'parent:{child_id}'])
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            tm_tgt = _make_tm(target)
+            registry = _make_mock_registry(target)
+
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+
+            with patch.object(mixin, '_pick_project_fuzzy', return_value='target-proj'), \
+                 patch('jot.commands._transfer_mixin.TaskManager', return_value=tm_tgt), \
+                 patch('jot.commands._transfer_mixin.CategoryManager'), \
+                 patch('builtins.input', return_value='y'):
+                mixin.move_task_to_project()
+
+            assert len(tm_src.tasks) == 0
+            assert len(tm_tgt.tasks) == 3
+
+            new_root_id = tm_tgt.tasks[0]['id']
+            new_child_id = tm_tgt.tasks[1]['id']
+            new_grandchild = tm_tgt.tasks[2]
+
+            assert f'parent:{new_root_id}' in tm_tgt.tasks[1]['labels']
+            assert f'parent:{new_child_id}' in new_grandchild['labels']
+
+    def test_move_cancelled_on_subtask_confirm(self):
+        """User declining subtask confirmation aborts move."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Parent')
+            pid = tm_src.tasks[0]['id']
+            tm_src.add_task('Child', labels=[f'parent:{pid}'])
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            registry = _make_mock_registry(target)
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+
+            with patch.object(mixin, '_pick_project_fuzzy', return_value='target-proj'), \
+                 patch('builtins.input', return_value='n'):
+                mixin.move_task_to_project()
+
+            # Nothing should have been removed
+            assert len(tm_src.tasks) == 2
+
+
+class TestCopyTaskWithSubtasks:
+    """Tests for copying parent + descendants to another project."""
+
+    def test_copy_parent_with_children(self):
+        """Copy parent + children, originals preserved."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            source = tmpdir / 'source'
+            target = tmpdir / 'target'
+            source.mkdir()
+            target.mkdir()
+
+            tm_src = _make_tm(source)
+            tm_src.add_task('Parent')
+            pid = tm_src.tasks[0]['id']
+            tm_src.add_task('Child', labels=[f'parent:{pid}'])
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            tm_tgt = _make_tm(target)
+            registry = _make_mock_registry(target)
+
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+
+            with patch.object(mixin, '_pick_project_fuzzy', return_value='target-proj'), \
+                 patch('jot.commands._transfer_mixin.TaskManager', return_value=tm_tgt), \
+                 patch('jot.commands._transfer_mixin.CategoryManager'), \
+                 patch('builtins.input', return_value='y'):
+                mixin.copy_task_to_project()
+
+            # Source unchanged
+            assert len(tm_src.tasks) == 2
+
+            # Target has copies with remapped IDs
+            assert len(tm_tgt.tasks) == 2
+            new_pid = tm_tgt.tasks[0]['id']
+            assert tm_tgt.tasks[0]['text'] == 'Parent'
+            assert f'parent:{new_pid}' in tm_tgt.tasks[1]['labels']
+
+
+class TestTransferCategoryWithSubtasks:
+    """Tests for transferring parent + descendants to another category."""
+
+    def test_transfer_parent_with_children(self):
+        """Transfer parent + children to different category."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+
+            # Source category
+            cat_dir = tmpdir / '.jot-categories'
+            cat_dir.mkdir()
+            src_dir = cat_dir / 'work'
+            src_dir.mkdir()
+            dest_dir = cat_dir / 'personal'
+            dest_dir.mkdir()
+
+            tm_src = _make_tm(src_dir)
+            tm_src.add_task('Parent')
+            pid = tm_src.tasks[0]['id']
+            tm_src.add_task('Child', labels=[f'parent:{pid}'])
+            tm_src.tasks[0]['current'] = True
+            tm_src._save_tasks()
+
+            tm_dest = _make_tm(dest_dir)
+
+            registry = MagicMock()
+            mixin = _make_transfer_mixin(tm_src, registry=registry)
+            mixin.task_manager.category = 'work'
+            mixin.task_manager.is_global = False
+            mixin.task_manager.project_dir = tmpdir
+
+            mock_picker_result = MagicMock()
+            mock_picker_result.value = ('personal', False)
+
+            with patch('jot.commands._transfer_mixin.CategoryManager') as MockCM, \
+                 patch('jot.commands._transfer_mixin.CategoryConfig'), \
+                 patch('jot.commands._transfer_mixin.quick_picker', return_value=mock_picker_result), \
+                 patch('jot.commands._transfer_mixin.TaskManager', return_value=tm_dest), \
+                 patch('builtins.input', side_effect=['y', '']):
+                mock_cm = MockCM.return_value
+                mock_cm.discover_categories.return_value = ['work', 'personal']
+                mock_cm.discover_global_categories.return_value = []
+                mixin.transfer_task_to_category()
+
+            # Source cleared
+            assert len(tm_src.tasks) == 0
+
+            # Dest has both with remapped parent
+            assert len(tm_dest.tasks) == 2
+            new_pid = tm_dest.tasks[0]['id']
+            assert tm_dest.tasks[0]['text'] == 'Parent'
+            assert f'parent:{new_pid}' in tm_dest.tasks[1]['labels']
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_mock_registry(target_path):
+    """Create a mock registry that returns target_path."""
+    registry = MagicMock()
+    registry.get_project_path.return_value = str(target_path)
+    return registry
+
+
+def _make_transfer_mixin(task_manager, registry=None):
+    """Create a minimal TransferMixin instance for testing."""
+    from jot.commands._transfer_mixin import TransferMixin
+
+    class TestHandler(TransferMixin):
+        def __init__(self, tm, reg):
+            self.task_manager = tm
+            self.registry = reg
+
+    return TestHandler(task_manager, registry)