lemming-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemming-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: An autonomous, iterative task runner for AI coding agents.
 Project-URL: Homepage, https://github.com/owahltinez/lemming
 Project-URL: Repository, https://github.com/owahltinez/lemming
@@ -186,11 +186,17 @@ Lemming comes with several built-in hooks to help manage your project:
   analyzes the results of the finished task and decides if the remaining roadmap
   needs to be adjusted (e.g., adding a missing prerequisite, skipping obsolete
   tasks, or breaking down a broad task).
-- **`readability`**: A code quality hook that reviews changes for adherence to
-  the Google Style Guide and general readability using the
+- **`readability`**: A code quality and simplification hook that challenges
+  unnecessary complexity and duplicate implementations, then reviews changes
+  for adherence to the Google Style Guide and general readability using the
   [readability](https://github.com/owahltinez/readability) tool (exposed as
   `lemming readability`). It can record findings as task progress or suggest
   follow-up refactoring tasks.
+- **`testing`**: Verifies that changed behavior has focused test coverage and
+  that the relevant tests pass.
+- **`ux`**: Reviews at most one critical user journey affected by a
+  user-visible change. It reports only concrete, reproducible continuity gaps
+  and exits immediately for non-user-facing tasks.
 
 ### Custom and Global Hooks
 
@@ -307,10 +313,12 @@ Lemming uses **fuzzy matching** to automatically inject the correct "YOLO"
 - **Antigravity (`agy`)**: Adds `--dangerously-skip-permissions`
 - **Aider**: Adds `--yes --quiet`
 - **Claude**: Adds `--dangerously-skip-permissions`
-- **Codex**: Adds `--yolo`
+- **Codex**: Runs non-interactively via `codex exec`, adds `--json`, and, in
+  YOLO mode, adds `--dangerously-bypass-approvals-and-sandbox`
 
-You can disable this behavior with `--no-defaults`, or use a **template** to
-fully control the command layout:
+You can disable default flag injection with `--no-defaults` (`codex exec`
+remains the Codex execution interface), or use a **template** to fully control
+the command layout:
 
 ```bash
 lemming run --runner "my-tool --input={{prompt}} --json"

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/README.md

@@ -164,11 +164,17 @@ Lemming comes with several built-in hooks to help manage your project:
   analyzes the results of the finished task and decides if the remaining roadmap
   needs to be adjusted (e.g., adding a missing prerequisite, skipping obsolete
   tasks, or breaking down a broad task).
-- **`readability`**: A code quality hook that reviews changes for adherence to
-  the Google Style Guide and general readability using the
+- **`readability`**: A code quality and simplification hook that challenges
+  unnecessary complexity and duplicate implementations, then reviews changes
+  for adherence to the Google Style Guide and general readability using the
   [readability](https://github.com/owahltinez/readability) tool (exposed as
   `lemming readability`). It can record findings as task progress or suggest
   follow-up refactoring tasks.
+- **`testing`**: Verifies that changed behavior has focused test coverage and
+  that the relevant tests pass.
+- **`ux`**: Reviews at most one critical user journey affected by a
+  user-visible change. It reports only concrete, reproducible continuity gaps
+  and exits immediately for non-user-facing tasks.
 
 ### Custom and Global Hooks
 
@@ -285,10 +291,12 @@ Lemming uses **fuzzy matching** to automatically inject the correct "YOLO"
 - **Antigravity (`agy`)**: Adds `--dangerously-skip-permissions`
 - **Aider**: Adds `--yes --quiet`
 - **Claude**: Adds `--dangerously-skip-permissions`
-- **Codex**: Adds `--yolo`
+- **Codex**: Runs non-interactively via `codex exec`, adds `--json`, and, in
+  YOLO mode, adds `--dangerously-bypass-approvals-and-sandbox`
 
-You can disable this behavior with `--no-defaults`, or use a **template** to
-fully control the command layout:
+You can disable default flag injection with `--no-defaults` (`codex exec`
+remains the Codex execution interface), or use a **template** to fully control
+the command layout:
 
 ```bash
 lemming run --runner "my-tool --input={{prompt}} --json"

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/docs/HOOKS.md

@@ -51,15 +51,30 @@ a broad task).
 
 ### `readability`
 
-A code quality hook that reviews changes for adherence to the Google Style Guide
-and general readability using the bundled `lemming readability` tool. It
-provides feedback via task progress or suggests follow-up refactoring tasks.
+A code quality and simplification hook that challenges unnecessary complexity,
+indirection, and duplicated implementations before reviewing changes for
+adherence to the Google Style Guide and general readability using the bundled
+`lemming readability` tool. It provides feedback via task progress or suggests
+follow-up refactoring tasks.
+
+### `testing`
+
+Checks that changed behavior has focused test coverage and runs the relevant
+tests. It records larger testing gaps as task progress for the roadmap hook.
+
+### `ux`
+
+A lightweight journey-continuity review for user-visible changes. It considers
+at most one affected critical journey, reports only concrete and reproducible
+gaps, and exits immediately when the task did not change user-facing behavior.
+It runs after `testing` and before `roadmap`.
 
 ### Editing Built-in Hook Prompts
 
 The built-in hook prompts are load-bearing: a wording change can regress
 orchestration behavior without any unit test failing. When you edit a prompt
-under `src/lemming/prompts/hooks/`, run its eval suite before shipping:
+under `src/lemming/prompts/hooks/` that has an eval suite, run it before
+shipping:
 
 ```bash
 uv run python -m lemming.evals run --suite roadmap

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/package-lock.json

@@ -12,7 +12,7 @@
         "@biomejs/biome": "1.9.4",
         "@playwright/test": "^1.60.0",
         "jsdom": "latest",
-        "mancha": "^0.22.4",
+        "mancha": "^0.22.7",
         "playwright": "^1.60.0"
       }
     },
@@ -1019,9 +1019,9 @@
       }
     },
     "node_modules/mancha": {
-      "version": "0.22.4",
-      "resolved": "https://registry.npmjs.org/mancha/-/mancha-0.22.4.tgz",
-      "integrity": "sha512-bNurE3cVS3ZoOow3hhkJiJcxRkXCZrWh4NaVVlV1KYFe3iY3wrcAqk/HJKMHw0kglcQjUc2iAtJbemI2oJKIUg==",
+      "version": "0.22.7",
+      "resolved": "https://registry.npmjs.org/mancha/-/mancha-0.22.7.tgz",
+      "integrity": "sha512-ZClxBTYOKSD9f4KqW8lCMYVEUPhxzIRgihw5g20QrD4kzZ9JcQ383LXXkPMVTaCAjLlqYaF3brUMYACwWgQZgA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/package.json

@@ -16,7 +16,7 @@
     "@biomejs/biome": "1.9.4",
     "@playwright/test": "^1.60.0",
     "jsdom": "latest",
-    "mancha": "^0.22.4",
+    "mancha": "^0.22.7",
     "playwright": "^1.60.0"
   }
 }

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lemming-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "An autonomous, iterative task runner for AI coding agents."
 readme = "README.md"
 authors = [

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/api/hooks_test.py

@@ -15,6 +15,9 @@ def test_list_hooks(client, test_tasks, monkeypatch, tmp_path):
     assert hooks["roadmap"]["masked"] is False
     assert hooks["readability"]["source"] == "built-in"
     assert hooks["readability"]["runs_on_failure"] is False
+    assert hooks["ux"]["priority"] == 70
+    assert hooks["ux"]["source"] == "built-in"
+    assert hooks["ux"]["runs_on_failure"] is False
 
     # Hooks are sorted by ascending priority
     priorities = [h["priority"] for h in payload]

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/evals/readability.py

@@ -56,6 +56,38 @@ def subtract(a: float, b: float) -> float:
     return a - b
 '''
 
+_DUPLICATED_BEHAVIOR_OPS = (
+    '"""Arithmetic operations for the calculator CLI."""\n\n'
+    '''import math
+
+
+def add(a: float, b: float) -> float:
+    """Returns the sum of two numbers."""
+    return a + b
+
+
+def subtract(a: float, b: float) -> float:
+    """Returns the difference of two numbers."""
+    return a - b
+
+
+def add_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready sum."""
+    total = a + b
+    if not math.isfinite(total):
+        raise ValueError("Receipt totals must be finite.")
+    return round(total, 2)
+
+
+def subtract_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready difference."""
+    total = a - b
+    if not math.isfinite(total):
+        raise ValueError("Receipt totals must be finite.")
+    return round(total, 2)
+'''
+)
+
 _OPS_TEST = """import unittest
 
 from calc import ops
@@ -69,6 +101,31 @@ class TestOps(unittest.TestCase):
         self.assertEqual(ops.subtract(5, 3), 2)
 """
 
+_DUPLICATED_BEHAVIOR_TEST = """import unittest
+
+from calc import ops
+
+
+class TestOps(unittest.TestCase):
+    def test_add(self):
+        self.assertEqual(ops.add(2, 3), 5)
+
+    def test_subtract(self):
+        self.assertEqual(ops.subtract(5, 3), 2)
+
+    def test_add_for_receipt(self):
+        self.assertEqual(ops.add_for_receipt(2.126, 1), 3.13)
+
+    def test_subtract_for_receipt(self):
+        self.assertEqual(ops.subtract_for_receipt(5.126, 2), 3.13)
+
+    def test_receipt_totals_must_be_finite(self):
+        with self.assertRaises(ValueError):
+            ops.add_for_receipt(float("inf"), 1)
+        with self.assertRaises(ValueError):
+            ops.subtract_for_receipt(float("inf"), 1)
+"""
+
 # A messy module the finished task did NOT touch: tempting to clean up,
 # but strictly out of scope for the hook.
 _MESSY_LEGACY = '''"""Legacy report formatting kept for compatibility."""
@@ -104,14 +161,18 @@ _BASE_PROGRESS = [
 ]
 
 
-def _write_project(workspace: pathlib.Path, ops_source: str) -> None:
+def _write_project(
+    workspace: pathlib.Path,
+    ops_source: str,
+    test_source: str = _OPS_TEST,
+) -> None:
     """Seeds the fixture project with the given ops module."""
     fixtures.init_repo(
         workspace,
         {
             "calc/__init__.py": "",
             "calc/ops.py": ops_source,
-            "calc/ops_test.py": _OPS_TEST,
+            "calc/ops_test.py": test_source,
             "calc/legacy.py": _MESSY_LEGACY,
             "README.md": "# Calculator CLI\n",
         },
@@ -253,6 +314,66 @@ def _grade_dead_code(workspace: pathlib.Path) -> list[scenarios.Check]:
     return [*checks, acted, interface]
 
 
+def _build_duplicated_behavior(workspace: pathlib.Path) -> None:
+    """Fixture: two live functions duplicate receipt preparation."""
+    _write_project(
+        workspace,
+        _DUPLICATED_BEHAVIOR_OPS,
+        _DUPLICATED_BEHAVIOR_TEST,
+    )
+    _save_finished_task(
+        workspace,
+        [
+            "Modified calc/ops.py and calc/ops_test.py to add receipt-ready "
+            "addition and subtraction; all tests pass.",
+        ],
+    )
+
+
+def _grade_duplicated_behavior(
+    workspace: pathlib.Path,
+) -> list[scenarios.Check]:
+    """The hook must consolidate or report live near-duplicate behavior."""
+    checks = _common_checks(workspace)
+
+    roadmap, load_failures = scenarios.load_or_fail(workspace)
+    if roadmap is None:
+        return load_failures
+
+    source = (workspace / "calc" / "ops.py").read_text()
+    repeated_validation = source.count("math.isfinite(total)") > 1
+    repeated_rounding = source.count("round(total, 2)") > 1
+    consolidated = not repeated_validation and not repeated_rounding
+
+    task = next(t for t in roadmap.tasks if t.id == "task1")
+    new_entries = task.progress[1:]
+    reported = any(
+        "duplicat" in entry.lower()
+        and ("add_for_receipt" in entry or "subtract_for_receipt" in entry)
+        for entry in new_entries
+    )
+    acted = scenarios.Check(
+        name="acted-on-live-duplication",
+        passed=consolidated or reported,
+        detail=(
+            "live receipt logic stayed duplicated and no finding was recorded"
+        )
+        if not (consolidated or reported)
+        else "",
+    )
+
+    interface = scenarios.Check(
+        name="receipt-interface-preserved",
+        passed=(
+            "def add_for_receipt(" in source
+            and "def subtract_for_receipt(" in source
+        ),
+        detail="a public receipt operation disappeared",
+    )
+
+    return [*checks, acted, interface]
+
+
 def _build_scope_limit(workspace: pathlib.Path) -> None:
     """Fixture: an untouched legacy file is messy but out of scope."""
     _write_project(workspace, _CLEAN_OPS)
@@ -302,6 +423,17 @@ SCENARIOS = [
         build=_build_dead_code,
         grade=_grade_dead_code,
     ),
+    scenarios.Scenario(
+        name="consolidate-or-report-live-duplication",
+        hook="readability",
+        outcome=models.TaskStatus.COMPLETED,
+        task_id="task1",
+        summary=(
+            "Consolidates near-duplicate live behavior or records a finding."
+        ),
+        build=_build_duplicated_behavior,
+        grade=_grade_duplicated_behavior,
+    ),
     scenarios.Scenario(
         name="scope-limited-to-changed-files",
         hook="readability",

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/evals/readability_test.py

@@ -38,7 +38,7 @@ class TestSuiteRegistry(ScenarioTestCase):
         self.assertIn("readability", registry)
         names = [s.name for s in registry["readability"]]
         self.assertEqual(len(names), len(set(names)))
-        self.assertEqual(len(names), 4)
+        self.assertEqual(len(names), 5)
 
 
 class TestFastExitScenario(ScenarioTestCase):
@@ -117,6 +117,85 @@ class TestDeadCodeScenario(ScenarioTestCase):
         self.assertIn("interface-preserved", self.failed_names(checks))
 
 
+class TestDuplicatedBehaviorScenario(ScenarioTestCase):
+    def test_ignoring_live_duplication_fails(self):
+        self.build("consolidate-or-report-live-duplication")
+
+        checks = self.scenario.grade(self.workspace)
+        self.assertEqual(
+            self.failed_names(checks),
+            {"acted-on-live-duplication"},
+        )
+
+    def test_consolidating_live_duplication_passes(self):
+        self.build("consolidate-or-report-live-duplication")
+        ops = self.workspace / "calc" / "ops.py"
+        source = ops.read_text()
+        source = source.replace(
+            '''def add_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready sum."""
+    total = a + b
+    if not math.isfinite(total):
+        raise ValueError("Receipt totals must be finite.")
+    return round(total, 2)
+
+
+def subtract_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready difference."""
+    total = a - b
+    if not math.isfinite(total):
+        raise ValueError("Receipt totals must be finite.")
+    return round(total, 2)
+''',
+            '''def _for_receipt(total: float) -> float:
+    """Validates and rounds a receipt total."""
+    if not math.isfinite(total):
+        raise ValueError("Receipt totals must be finite.")
+    return round(total, 2)
+
+
+def add_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready sum."""
+    return _for_receipt(a + b)
+
+
+def subtract_for_receipt(a: float, b: float) -> float:
+    """Returns a validated, receipt-ready difference."""
+    return _for_receipt(a - b)
+''',
+        )
+        ops.write_text(source)
+
+        checks = self.scenario.grade(self.workspace)
+        self.assertEqual(self.failed_names(checks), set())
+
+    def test_recording_live_duplication_passes(self):
+        self.build("consolidate-or-report-live-duplication")
+        tasks.add_progress(
+            self.tasks_file,
+            "task1",
+            "Readability: add_for_receipt() and subtract_for_receipt() "
+            "duplicate receipt validation and rounding; consolidate them "
+            "behind one helper.",
+        )
+
+        checks = self.scenario.grade(self.workspace)
+        self.assertEqual(self.failed_names(checks), set())
+
+    def test_deleting_receipt_operation_fails(self):
+        self.build("consolidate-or-report-live-duplication")
+        ops = self.workspace / "calc" / "ops.py"
+        source = ops.read_text()
+        start = source.index("def subtract_for_receipt")
+        ops.write_text(source[:start])
+
+        checks = self.scenario.grade(self.workspace)
+        self.assertIn(
+            "receipt-interface-preserved",
+            self.failed_names(checks),
+        )
+
+
 class TestScopeLimitScenario(ScenarioTestCase):
     def test_leaving_legacy_alone_passes(self):
         self.build("scope-limited-to-changed-files")

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/hooks_test.py

@@ -30,6 +30,8 @@ def test_list_hooks_includes_all(tmp_path, monkeypatch):
 
     assert "roadmap" in active
     assert "readability" in active
+    assert "testing" in active
+    assert "ux" in active
     assert "custom_hook" in active
 
 
@@ -47,6 +49,9 @@ def test_list_hooks_orders_by_priority(tmp_path, monkeypatch):
     # Numeric prefix orders execution; built-in roadmap (90) runs last
     assert active[0] == "early"
     assert active[-1] == "roadmap"
+    assert active.index("readability") < active.index("testing")
+    assert active.index("testing") < active.index("ux")
+    assert active.index("ux") < active.index("roadmap")
     assert active.index("zz_hook") < active.index("roadmap")
 
 

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/models.py

@@ -56,6 +56,7 @@ class Task(pydantic.BaseModel):
     last_started_at: float | None = None
     created_at: float = pydantic.Field(default_factory=time.time)
     run_time: float = 0.0
+    execution_times: dict[str, float] | None = None
     pid: int | None = None
     last_heartbeat: float | None = None
     has_runner_log: bool = False

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/models_test.py

@@ -17,6 +17,7 @@ def test_task_model_defaults():
     assert task.attempts == 0
     assert task.progress == []
     assert task.run_time == 0.0
+    assert task.execution_times is None
     assert task.created_at > 0
 
 

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/prompts/hooks/50-readability.md

@@ -18,7 +18,20 @@ keeps quality from drifting as tasks accumulate.
 1.  **Automate**: Immediately run `lemming readability check <path> --fix` for
     every file modified or created in the last task. This handles standard
     formatting (ruff, biome, prettier) and type checking (pyrefly).
-2.  **Review**: Read the changed files and look for quality drift that automated
+2.  **Challenge the Shape**: Before polishing the implementation, ask whether
+    the same behavior could use fewer concepts, files, branches, dependencies,
+    or abstractions. Prefer removing indirection over adding another layer.
+    In particular, look for:
+    - **Duplication and drift**: parallel implementations of the same behavior
+      or knowledge with only small variations. Reuse or consolidate an existing
+      implementation and parameterize genuine differences so there is one
+      source of truth.
+    - **False reuse**: code that merely looks similar but represents different
+      concepts. Do not force one-off similarities into a premature abstraction
+      just to satisfy DRY.
+    Make only local, behavior-preserving simplifications within the files
+    changed by the task. Record broader redesigns as progress.
+3.  **Review**: Read the changed files and look for quality drift that automated
     tools cannot catch:
     - **Excess complexity**: deep nesting, sprawling functions, needless
       indirection or premature abstraction, dead or duplicated code.
@@ -26,24 +39,24 @@ keeps quality from drifting as tasks accumulate.
       developer of the language would not write.
     - **Inconsistency**: code that diverges from the conventions of the
       surrounding codebase, or comments that no longer match the code.
-3.  **Consult**: Fetch the style guide with
+4.  **Consult**: Fetch the style guide with
     `lemming readability guide <language>` when reviewing and cite the relevant
     rule in your findings. Do not rely on memory for style rules.
-4.  **Fix**: Apply targeted, behavior-preserving fixes for the issues you find.
+5.  **Fix**: Apply targeted, behavior-preserving fixes for the issues you find.
     Keep each fix small and scoped to the files changed in the last task. Do not
     change public interfaces, feature behavior, or unrelated files; record those
     findings as progress instead of fixing them.
-5.  **Verify**: After any manual fix, run the relevant tests and re-run
+6.  **Verify**: After any manual fix, run the relevant tests and re-run
     `lemming readability check <path>`. If verification fails and the fix is not
     trivially repaired, revert your edits and record the finding as progress
     rather than letting changes snowball.
-6.  **Report**: Record meaningful findings and applied fixes as progress using
+7.  **Report**: Record meaningful findings and applied fixes as progress using
     `lemming progress {{finished_task_id}} '<finding>'`.
-7.  **No Orchestration**: Do NOT add new tasks to the roadmap. If you identify
+8.  **No Orchestration**: Do NOT add new tasks to the roadmap. If you identify
     significant issues that require follow-up work (e.g. a refactor spanning
     unrelated files), record them as progress so the roadmap hook can decide
     whether to add a new task.
-8.  **Fast Exit**: If the automated checks pass and your review finds no drift,
+9.  **Fast Exit**: If the automated checks pass and your review finds no drift,
     exit immediately.
 
 ## Commands

lemming_cli-0.2.1/src/lemming/prompts/hooks/70-ux.md

@@ -0,0 +1,55 @@
+# UX Journey Hook
+
+You are a lightweight reviewer of the user journey affected by the task that
+just finished. Your role is to catch concrete interaction dead ends that code
+quality and unit-test review can miss, without turning each task into a general
+UX audit.
+
+## Context
+
+{{roadmap}}
+
+## Finished Task
+
+{{finished_task}}
+
+## Directives
+
+1.  **Applicability Gate**: First decide whether the finished task changed
+    user-visible behavior in a UI, CLI, API, workflow, documentation path, or
+    user-facing error. If it did not, exit immediately without running commands
+    or recording progress.
+2.  **Use the Contract**: Read applicable project instructions and existing
+    UX or journey documentation, if present. Otherwise use the task acceptance
+    criteria and observed user-facing behavior as the contract. Do not invent
+    personas, product requirements, aesthetic preferences, or new journey
+    documentation.
+3.  **Review One Journey**: Identify at most one critical journey directly
+    affected by this task and check only:
+    - Can the user discover and start it?
+    - Can the user complete its happy path within any documented step budget?
+    - Are failures understandable and recoverable without losing important
+      state?
+    - Is successful completion communicated accessibly and unambiguously?
+4.  **Require Evidence**: Report only a concrete, reproducible gap tied to a
+    requirement, changed behavior, failing assertion, or missing state
+    transition. Never judge a screenshot or self-certify subjective visual
+    quality. Prefer the project's existing focused checks and measurements.
+5.  **Stay Advisory**: Do NOT modify source files, tests, documentation, or the
+    roadmap. Do NOT rerun broad test suites already covered by the testing hook.
+    Record findings as progress so the roadmap hook can decide whether
+    follow-up work is necessary.
+6.  **Limit Output**: Record at most two findings. Each finding must name the
+    affected journey, the exact break or risk, and the evidence needed to close
+    it. If there is no concrete gap, exit immediately without recording a
+    generic approval or summary.
+
+## Command
+
+```bash
+lemming --tasks-file {{tasks_file_path}} progress {{finished_task_id}} '<finding>'
+```
+
+Limit the review to behavior affected by the finished task. This is a journey
+continuity check, not a design review, accessibility audit,
+feature-completeness review, or request for polish.

{lemming_cli-0.2.0 → lemming_cli-0.2.1}/src/lemming/prompts_test.py

@@ -9,6 +9,24 @@ def test_load_prompt():
     assert "description" in prompt
 
 
+def test_load_builtin_ux_prompt():
+    prompt = prompts.load_prompt("ux")
+
+    assert "Applicability Gate" in prompt
+    assert "Review One Journey" in prompt
+    assert "{{finished_task}}" in prompt
+    assert "{{finished_task_id}}" in prompt
+
+
+def test_load_builtin_readability_prompt_includes_simplification():
+    prompt = prompts.load_prompt("readability")
+
+    assert "Challenge the Shape" in prompt
+    assert "Duplication and drift" in prompt
+    assert "source of truth" in prompt
+    assert "False reuse" in prompt
+
+
 def test_prepare_prompt(tmp_path):
     tasks_file = tmp_path / "tasks.yml"
     data = tasks.Roadmap(