jott-cli 0.7.1__tar.gz → 0.8.1__tar.gz

{jott_cli-0.7.1/jott_cli.egg-info → jott_cli-0.8.1}/PKG-INFO

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

@@ -7,7 +7,7 @@ import importlib.util
 import os
 from pathlib import Path
 
-__version__ = "0.7.1"
+__version__ = "0.8.1"
 
 # 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.7.1 → jott_cli-0.8.1}/jot/app.py

@@ -84,6 +84,11 @@ class App(DispatchMixin, AppNavigationMixin):
             os.path.getmtime(task_manager.storage_file)
             if task_manager.storage_file.exists() else 0)
 
+        try:
+            task_manager._migrate_legacy_deleted_notes()
+        except Exception as e:
+            print(f"Warning: deleted-notes migration failed: {e}")
+
     # ------------------------------------------------------------------
     # Public entry point
     # ------------------------------------------------------------------

{jott_cli-0.7.1 → jott_cli-0.8.1}/jot/commands/_metadata_mixin.py

@@ -7,7 +7,7 @@ from jot.ui.picker import PickerItem, quick_picker, fuzzy_picker
 from jot.ui.styles import (
     RESET, BOLD, DIM, GREEN, RED,
     PRIORITY_COLORS, PRIORITY_SYMBOLS, STATUS_COLORS, STATUS_SYMBOLS,
-    HIGHLIGHT_COLORS,
+    HIGHLIGHT_COLORS, STATE_ORDER, STATE_COLORS,
 )
 from jot.ui.input import restore_terminal
 
@@ -125,20 +125,29 @@ class MetadataMixin:
         return True
 
     def toggle_highlight(self):
-        """Pick a highlight color for the current task, or clear it."""
+        """Pick a task state (color-coded) for the current task."""
         current_task = self.task_manager.get_current_task()
         if not current_task:
             return True
 
-        items = [PickerItem(value="_clear", label="none (clear)", color=DIM)]
-        for name, fmt in HIGHLIGHT_COLORS.items():
-            items.append(PickerItem(
-                value=name, label=name, color=fmt,
-            ))
+        items = []
+        for state in STATE_ORDER:
+            color_key = STATE_COLORS[state]
+            if color_key is None:
+                items.append(PickerItem(
+                    value="_clear", label="none", color=DIM,
+                    annotation=state,
+                ))
+            else:
+                items.append(PickerItem(
+                    value=color_key, label=color_key,
+                    color=HIGHLIGHT_COLORS[color_key],
+                    annotation=state,
+                ))
 
         result = quick_picker(
             items,
-            prompt=f"Highlight color for: {current_task['text']}",
+            prompt=f"State for: {current_task['text']}",
         )
 
         if result.value is None:
@@ -146,11 +155,13 @@ class MetadataMixin:
 
         if result.value == "_clear":
             self.task_manager.set_highlight(color=None)
-            print(f"\n{GREEN}✓{RESET} Highlight cleared")
+            print(f"\n{GREEN}✓{RESET} State cleared (backlog)")
         else:
             self.task_manager.set_highlight(color=result.value)
             fmt = HIGHLIGHT_COLORS[result.value]
-            print(f"\n{GREEN}✓{RESET} Highlight set to {fmt} {result.value} {RESET}")
+            from jot.ui.styles import COLOR_TO_STATE
+            state_name = COLOR_TO_STATE.get(result.value, result.value)
+            print(f"\n{GREEN}✓{RESET} State: {fmt} {state_name} {RESET}")
 
         print("\nPress Enter to continue...", end='', flush=True)
         restore_terminal()

{jott_cli-0.7.1 → jott_cli-0.8.1}/jot/core/_delete_mixin.py

@@ -1,12 +1,55 @@
-"""Delete mixin — archive, permanent delete, notes export."""
+"""Delete mixin, archive, permanent delete, notes export."""
 
 import os
+import re
 from datetime import datetime
 
 
+DELETED_NOTES_DIR = ".jot-deleted-notes"
+_DELETED_NOTES_FILENAME_RE = re.compile(
+    r"^TASK-\d+-notes-\d{8}_\d{6}\.org$"
+)
+
+
 class DeleteMixin:
     """Task removal, archival, and notes preservation."""
 
+    def _migrate_legacy_deleted_notes(self):
+        """Move stray TASK-<id>-notes-<ts>.org files from project_dir
+        into the DELETED_NOTES_DIR subdirectory. Idempotent: a no-op
+        when no matching files exist at the project root.
+        """
+        try:
+            entries = list(self.project_dir.iterdir())
+        except (OSError, AttributeError):
+            return 0
+
+        matches = [
+            p for p in entries
+            if p.is_file() and _DELETED_NOTES_FILENAME_RE.match(p.name)
+        ]
+        if not matches:
+            return 0
+
+        dest_dir = self.project_dir / DELETED_NOTES_DIR
+        try:
+            dest_dir.mkdir(exist_ok=True)
+        except OSError as e:
+            print(f"Warning: could not create {dest_dir}: {e}")
+            return 0
+
+        moved = 0
+        for src in matches:
+            dest = dest_dir / src.name
+            if dest.exists():
+                continue
+            try:
+                src.rename(dest)
+                moved += 1
+            except OSError as e:
+                print(f"Warning: could not move {src.name}: {e}")
+        return moved
+
     def _unlink_children(self, task_id):
         """Remove parent:{task_id} labels from all children."""
         parent_label = f"parent:{task_id}"
@@ -131,7 +174,13 @@ class DeleteMixin:
         )
 
         filename = f"TASK-{task_id}-notes-{now.strftime('%Y%m%d_%H%M%S')}.org"
-        org_file_path = self.project_dir / filename
+        dest_dir = self.project_dir / DELETED_NOTES_DIR
+        try:
+            dest_dir.mkdir(exist_ok=True)
+        except OSError as e:
+            print(f"Warning: Could not create {dest_dir}: {e}")
+            return None
+        org_file_path = dest_dir / filename
 
         try:
             with open(org_file_path, 'w') as f:

{jott_cli-0.7.1 → jott_cli-0.8.1}/jot/core/_metadata_mixin.py

@@ -3,6 +3,18 @@
 from datetime import datetime, timezone
 
 
+# One-way mapping from legacy status values to highlight color keys.
+# Setting status auto-paints the highlight; the reverse is NOT applied.
+# Status is being deprecated in favor of the richer state palette;
+# this exists so the legacy `* status` picker still does something useful.
+_STATUS_TO_HIGHLIGHT = {
+    'todo': 'red',
+    'in-progress': 'orange',
+    'blocked': 'burnt',
+    'done': 'yellow',
+}
+
+
 class MetadataMixin:
     """Set task metadata: current flag, agent, day, priority, status, tally."""
 
@@ -118,6 +130,9 @@ class MetadataMixin:
                     task['done'] = True
                 elif task.get('done', False):
                     task['done'] = False
+                color = _STATUS_TO_HIGHLIGHT.get(status)
+                if color:
+                    task['highlight'] = color
                 self._save_tasks()
                 return True
         return False

{jott_cli-0.7.1 → jott_cli-0.8.1}/jot/ui/styles.py

@@ -49,26 +49,65 @@ BLACK = '\033[30m'
 # Background colors
 BG_YELLOW = '\033[103m'
 BG_ORANGE = '\033[48;5;208m'
+BG_BURNT_ORANGE = '\033[48;5;166m'
 BG_MAGENTA = '\033[105m'
 BG_GRAY = '\033[100m'
 BG_DARK_GRAY = '\033[48;5;236m'
 BG_CYAN = '\033[106m'
+BG_BLUE = '\033[48;5;33m'
 BG_RED = '\033[101m'
 BG_GREEN = '\033[102m'
 
-# Semantic mappings — highlight color palette
+# Semantic mappings, highlight color palette.
+# Each color maps to a task state in STATE_HIGHLIGHTS below; the legacy
+# `status` field is being deprecated in favor of these state-bearing
+# highlights.
 HIGHLIGHT_COLORS = {
     'gray': WHITE + BG_DARK_GRAY,
-    'yellow': BLACK + BG_YELLOW,
-    'orange': BLACK + BG_ORANGE,
     'magenta': WHITE + BG_MAGENTA,
     'cyan': BLACK + BG_CYAN,
     'red': WHITE + BG_RED,
+    'orange': BLACK + BG_ORANGE,
+    'burnt': WHITE + BG_BURNT_ORANGE,
+    'yellow': BLACK + BG_YELLOW,
+    'blue': WHITE + BG_BLUE,
     'green': BLACK + BG_GREEN,
 }
-HIGHLIGHT_DEFAULT = 'yellow'
+HIGHLIGHT_DEFAULT = 'gray'
 HIGHLIGHT_FMT = HIGHLIGHT_COLORS[HIGHLIGHT_DEFAULT]
 
+# Semantic mappings, task state pipeline.
+# Ordered from earliest to latest; STATE_COLORS[state] is the
+# highlight-color key (looks up into HIGHLIGHT_COLORS), or None for
+# the unhighlighted "backlog" state.
+STATE_ORDER = [
+    'backlog',
+    'needs-review',
+    'in-review',
+    'ready',
+    'todo',
+    'doing',
+    'blocked',
+    'done',
+    'shipping',
+    'complete',
+]
+STATE_COLORS = {
+    'backlog': None,
+    'needs-review': 'gray',
+    'in-review': 'magenta',
+    'ready': 'cyan',
+    'todo': 'red',
+    'doing': 'orange',
+    'blocked': 'burnt',
+    'done': 'yellow',
+    'shipping': 'blue',
+    'complete': 'green',
+}
+# Reverse lookup: highlight-color key → state name (for one-way
+# inference from the legacy color field if ever needed).
+COLOR_TO_STATE = {v: k for k, v in STATE_COLORS.items() if v is not None}
+
 # Semantic mappings — priority
 PRIORITY_COLORS = {
     'none': DIM,

{jott_cli-0.7.1 → jott_cli-0.8.1/jott_cli.egg-info}/PKG-INFO

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

@@ -84,7 +84,9 @@ jott_cli.egg-info/dependency_links.txt
 jott_cli.egg-info/entry_points.txt
 jott_cli.egg-info/requires.txt
 jott_cli.egg-info/top_level.txt
+tests/test_claude_org_prompt.py
 tests/test_command_handler.py
+tests/test_deleted_notes_dir.py
 tests/test_dispatch.py
 tests/test_edit_edge_cases.py
 tests/test_fuzzy_search.py
@@ -93,7 +95,9 @@ tests/test_github.py
 tests/test_highlight.py
 tests/test_input.py
 tests/test_jot.py
+tests/test_notes_tempfile_location.py
 tests/test_picker.py
+tests/test_state_palette.py
 tests/test_styles.py
 tests/test_subtask_notes.py
 tests/test_terminal_wrap.py

{jott_cli-0.7.1 → jott_cli-0.8.1}/pyproject.toml

@@ -7,7 +7,7 @@ include = ["jot", "jot.*"]
 
 [project]
 name = "jott-cli"
-version = "0.7.1"
+version = "0.8.1"
 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.8.1/tests/test_claude_org_prompt.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Tests for org-mode formatting instruction appended to Claude prompts."""
+
+import tempfile
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from jot import TaskManager
+from jot.commands.handler import CommandHandler
+from jot.commands._claude_mixin import _ORG_OUTPUT_INSTRUCTION
+
+
+def _make_handler(tmpdir: Path):
+    (tmpdir / ".jot-registry.json").write_text("{}")
+    tm = TaskManager(storage_file='.jot.json', directory=str(tmpdir))
+    return tm, CommandHandler(tm)
+
+
+def _fake_subprocess_result(stdout="* Result\nbody\n"):
+    return SimpleNamespace(stdout=stdout, stderr="", returncode=0)
+
+
+class TestOrgOutputInstruction:
+    def test_instruction_constant_mentions_org_markers(self):
+        # Sanity: ensure the constant actually directs to org-mode output.
+        assert '#+begin_src' in _ORG_OUTPUT_INSTRUCTION
+        assert 'Do NOT use markdown' in _ORG_OUTPUT_INSTRUCTION
+        assert '~symbol~' in _ORG_OUTPUT_INSTRUCTION or '=literal=' in _ORG_OUTPUT_INSTRUCTION
+
+    def test_instruction_appended_when_no_existing_notes(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("write a fizzbuzz")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'], existing_notes='',
+                    allow_edits=False,
+                )
+
+            assert mocked.called
+            prompt = mocked.call_args.kwargs['input']
+            assert prompt.startswith("write a fizzbuzz")
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)
+
+    def test_instruction_appended_when_existing_notes_present(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("rewrite the parser")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'],
+                    existing_notes='prior context here',
+                    allow_edits=False,
+                )
+
+            prompt = mocked.call_args.kwargs['input']
+            assert 'rewrite the parser' in prompt
+            assert 'prior context here' in prompt
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)
+
+    def test_instruction_appended_in_edit_mode(self):
+        # allow_edits=True path uses a different cmd but same prompt assembly.
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("apply diff")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'],
+                    existing_notes='notes',
+                    allow_edits=True,
+                )
+
+            prompt = mocked.call_args.kwargs['input']
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)

jott_cli-0.8.1/tests/test_deleted_notes_dir.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Tests for deleted-task notes living in .jot-deleted-notes/ subdir
+and the one-shot migration of legacy stray files at the project root.
+"""
+
+import tempfile
+from pathlib import Path
+
+from jot import TaskManager
+from jot.core._delete_mixin import DELETED_NOTES_DIR
+
+
+def _make_tm(tmpdir: Path) -> TaskManager:
+    # Pre-seed registry to avoid auto-discovery side effects.
+    (tmpdir / ".jot-registry.json").write_text("{}")
+    return TaskManager(storage_file='.jot.json', directory=str(tmpdir))
+
+
+class TestDeletedNotesDirectory:
+    def test_save_notes_writes_into_subdir(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+            tm.add_task("task with notes")
+            tid = tm.tasks[0]['id']
+            tm.tasks[0]['notes'] = "important context\nline two"
+
+            path = tm.save_notes_to_org_file(tid)
+
+            assert path is not None
+            p = Path(path)
+            assert p.parent.name == DELETED_NOTES_DIR
+            assert p.parent.parent == tmpdir
+            assert p.exists()
+            assert "important context" in p.read_text()
+
+    def test_remove_task_routes_notes_into_subdir(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+            tm.add_task("doomed task")
+            tid = tm.tasks[0]['id']
+            tm.tasks[0]['notes'] = "save me"
+
+            tm.remove_task(tid)
+
+            root_strays = list(tmpdir.glob("TASK-*-notes-*.org"))
+            subdir_files = list(
+                (tmpdir / DELETED_NOTES_DIR).glob("TASK-*-notes-*.org")
+            )
+            assert root_strays == []
+            assert len(subdir_files) == 1
+
+
+class TestLegacyNotesMigration:
+    def test_migrate_moves_matching_files(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+
+            (tmpdir / "TASK-1-notes-20260101_120000.org").write_text("a")
+            (tmpdir / "TASK-42-notes-20260518_235959.org").write_text("b")
+
+            moved = tm._migrate_legacy_deleted_notes()
+
+            assert moved == 2
+            assert list(tmpdir.glob("TASK-*-notes-*.org")) == []
+            dest = tmpdir / DELETED_NOTES_DIR
+            assert (dest / "TASK-1-notes-20260101_120000.org").exists()
+            assert (dest / "TASK-42-notes-20260518_235959.org").exists()
+
+    def test_migrate_is_noop_when_no_matches(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+
+            moved = tm._migrate_legacy_deleted_notes()
+
+            assert moved == 0
+            assert not (tmpdir / DELETED_NOTES_DIR).exists()
+
+    def test_migrate_ignores_non_matching_filenames(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+
+            keep = [
+                "TASK-rfc-notes-draft.org",
+                "TASK-1-notes-bad.org",
+                "task-1-notes-20260101_120000.org",
+                "TASK-1-notes-20260101_120000.txt",
+                "NOTES.org",
+            ]
+            for name in keep:
+                (tmpdir / name).write_text("x")
+
+            moved = tm._migrate_legacy_deleted_notes()
+
+            assert moved == 0
+            for name in keep:
+                assert (tmpdir / name).exists()
+
+    def test_migrate_does_not_clobber_existing_dest(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+
+            stray = tmpdir / "TASK-7-notes-20260101_120000.org"
+            stray.write_text("new")
+            dest_dir = tmpdir / DELETED_NOTES_DIR
+            dest_dir.mkdir()
+            existing = dest_dir / "TASK-7-notes-20260101_120000.org"
+            existing.write_text("original")
+
+            tm._migrate_legacy_deleted_notes()
+
+            assert stray.exists()
+            assert existing.read_text() == "original"
+
+    def test_migrate_idempotent(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm = _make_tm(tmpdir)
+            (tmpdir / "TASK-9-notes-20260202_020202.org").write_text("z")
+
+            first = tm._migrate_legacy_deleted_notes()
+            second = tm._migrate_legacy_deleted_notes()
+
+            assert first == 1
+            assert second == 0
+            assert (
+                tmpdir / DELETED_NOTES_DIR
+                / "TASK-9-notes-20260202_020202.org"
+            ).exists()

jott_cli-0.8.1/tests/test_notes_tempfile_location.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Tests that notes editor temp files are created inside the project dir
+(not /tmp), so editor/LSP can resolve project-local config and tools.
+"""
+
+import os
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from unittest.mock import patch
+
+from jot import TaskManager
+from jot.commands.handler import CommandHandler
+
+
+def _make_handler(tmpdir: Path):
+    (tmpdir / ".jot-registry.json").write_text("{}")
+    tm = TaskManager(storage_file='.jot.json', directory=str(tmpdir))
+    return tm, CommandHandler(tm)
+
+
+@contextmanager
+def _captured_edit(handler, editor):
+    """Run edit_task_notes() under stubs and yield the captured file_path."""
+    captured = {}
+
+    def fake_editor(file_path):
+        captured['path'] = file_path
+        return True
+
+    with patch.object(handler, 'safe_launch_editor', side_effect=fake_editor), \
+            patch('builtins.input', return_value=''), \
+            patch.dict(os.environ, {'EDITOR': editor}, clear=False):
+        handler.edit_task_notes()
+
+    yield captured['path']
+
+
+class TestNotesTempfileLocation:
+    def test_tempfile_created_inside_project_dir(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw).resolve()
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("a task")
+            tm.set_current(tm.tasks[0]['id'])
+
+            with _captured_edit(handler, 'nano') as path:
+                edited_path = Path(path).resolve()
+
+            # The temp file should live inside tmpdir, not in /tmp.
+            assert tmpdir in edited_path.parents, (
+                f"temp file {edited_path} not under project {tmpdir}"
+            )
+
+    def test_tempfile_uses_org_suffix_for_emacs(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw).resolve()
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("emacs task")
+            tm.set_current(tm.tasks[0]['id'])
+
+            with _captured_edit(handler, 'emacs -nw') as path:
+                assert path.endswith('.org')
+
+    def test_tempfile_uses_txt_suffix_for_other_editors(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw).resolve()
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("vim task")
+            tm.set_current(tm.tasks[0]['id'])
+
+            with _captured_edit(handler, 'vim') as path:
+                assert path.endswith('.txt')

jott_cli-0.8.1/tests/test_state_palette.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""Tests for the state-color palette and one-way status->highlight."""
+
+import tempfile
+from pathlib import Path
+
+from jot import TaskManager
+from jot.ui import styles
+from jot.ui.styles import (
+    HIGHLIGHT_COLORS,
+    HIGHLIGHT_DEFAULT,
+    STATE_ORDER,
+    STATE_COLORS,
+    COLOR_TO_STATE,
+)
+
+
+def _make_tm(tmpdir: Path) -> TaskManager:
+    (tmpdir / ".jot-registry.json").write_text("{}")
+    return TaskManager(storage_file='.jot.json', directory=str(tmpdir))
+
+
+class TestStatePalette:
+    def test_state_order_has_ten_entries(self):
+        assert len(STATE_ORDER) == 10
+
+    def test_state_order_is_pipeline_sequence(self):
+        assert STATE_ORDER == [
+            'backlog', 'needs-review', 'in-review', 'ready',
+            'todo', 'doing', 'blocked', 'done', 'shipping', 'complete',
+        ]
+
+    def test_every_state_has_a_color_entry(self):
+        for state in STATE_ORDER:
+            assert state in STATE_COLORS
+
+    def test_backlog_maps_to_no_color(self):
+        assert STATE_COLORS['backlog'] is None
+
+    def test_non_backlog_states_map_to_real_palette_keys(self):
+        for state in STATE_ORDER:
+            color = STATE_COLORS[state]
+            if color is None:
+                continue
+            assert color in HIGHLIGHT_COLORS, (
+                f"state {state} maps to unknown color {color}"
+            )
+
+    def test_state_colors_are_unique(self):
+        used = [c for c in STATE_COLORS.values() if c is not None]
+        assert len(used) == len(set(used)), "two states share a color"
+
+    def test_color_to_state_is_reverse_of_state_colors(self):
+        for color, state in COLOR_TO_STATE.items():
+            assert STATE_COLORS[state] == color
+
+    def test_burnt_and_blue_added_to_palette(self):
+        assert 'burnt' in HIGHLIGHT_COLORS
+        assert 'blue' in HIGHLIGHT_COLORS
+
+    def test_default_highlight_is_gray(self):
+        assert HIGHLIGHT_DEFAULT == 'gray'
+
+    def test_burnt_uses_256_color_166(self):
+        assert '48;5;166' in HIGHLIGHT_COLORS['burnt']
+
+    def test_blue_uses_256_color_33(self):
+        assert '48;5;33' in HIGHLIGHT_COLORS['blue']
+
+
+class TestStatusAutoHighlights:
+    def test_setting_todo_paints_red(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+
+            tm.set_task_status(tid, 'todo')
+
+            assert tm.tasks[0]['highlight'] == 'red'
+
+    def test_setting_in_progress_paints_orange(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+
+            tm.set_task_status(tid, 'in-progress')
+
+            assert tm.tasks[0]['highlight'] == 'orange'
+
+    def test_setting_blocked_paints_burnt(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+
+            tm.set_task_status(tid, 'blocked')
+
+            assert tm.tasks[0]['highlight'] == 'burnt'
+
+    def test_setting_done_paints_yellow(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+
+            tm.set_task_status(tid, 'done')
+
+            assert tm.tasks[0]['highlight'] == 'yellow'
+
+    def test_status_overrides_prior_highlight(self):
+        # Status change *always* repaints, since status is the driver.
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+            tm.set_current(tid)
+            tm.set_highlight(color='magenta')
+            assert tm.tasks[0]['highlight'] == 'magenta'
+
+            tm.set_task_status(tid, 'todo')
+
+            assert tm.tasks[0]['highlight'] == 'red'
+
+    def test_highlight_change_does_not_alter_status(self):
+        # One-way: highlight changes must not feed back into status.
+        with tempfile.TemporaryDirectory() as raw:
+            tm = _make_tm(Path(raw))
+            tm.add_task("x")
+            tid = tm.tasks[0]['id']
+            tm.set_current(tid)
+            tm.set_task_status(tid, 'todo')
+            assert tm.tasks[0]['status'] == 'todo'
+
+            tm.set_highlight(color='green')
+
+            assert tm.tasks[0]['status'] == 'todo'
+            assert tm.tasks[0]['highlight'] == 'green'