codee-agent 0.6.3__tar.gz → 0.6.4__tar.gz

{codee_agent-0.6.3 → codee_agent-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.6.3
+Version: 0.6.4
 Summary: A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents.
 Keywords: ai,agent,jira,azure-devops,claude-code,github-copilot,codex,automation
 Author: Denis Kibalko

{codee_agent-0.6.3 → codee_agent-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.6.3"
+version = "0.6.4"
 description = "A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents."
 readme = "README.md"
 license = "MIT"

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee/executor.py

@@ -11,8 +11,8 @@ from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_codex.provider import CodexAgent
 from codee_agent_github_copilot.provider import GitHubCopilotAgent
 from codee_main_context.context import (
-    CodeeMainContext, CodingAgent, STORY_ISSUE_TYPE, Settings,
-    codee_issue_types, data_dir, load_settings, project_root)
+    CodeeMainContext, CodingAgent, Settings, codee_issue_types, data_dir,
+    load_settings, project_root)
 from codee_main_context.logging import configure_logging, get_logger
 from codee_tasks_abstract.provider import AbstractTasksProvider
 
@@ -424,12 +424,16 @@ def run_once() -> None:
         log.info("Incoming %s (%s, %s, %s): %s",
                  task_id, status, issue_type, priority, summary)
 
-        # Children of a Codee-owned story are driven by that story's own agent
-        # run. What marks a story as Codee-owned is the provider's business.
-        if (issue_type.casefold() != STORY_ISSUE_TYPE
-                and task.is_parent_codee_story):
-            log.debug("Skipping %s: parent %s is a Codee story",
-                      task_id, task.parent.key)
+        # An item whose parent is one Codee polls in its own right is left
+        # alone: the parent's own run is what decides what its children need,
+        # and picking the child up here as well is two agents on one change.
+        # Its type is what says so — a work item selected by a query of the
+        # user's own shields nothing, since nothing in a parent says whether
+        # that condition would have claimed it.
+        if task.is_parent_codee_work_item:
+            log.debug("Skipping %s: its parent %s is a %s, which Codee polls "
+                      "in its own right",
+                      task_id, task.parent.key, task.parent.work_item_type)
             continue
 
         skill = match_issue_skill(issue_skills, status, issue_type)

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee/test_executor.py

@@ -12,8 +12,11 @@ from codee_main_context.context import (
 from codee_tasks_azure_devops.provider import AzureDevOpsTasksProvider
 from codee_tasks_jira.provider import JiraTasksProvider
 
+from codee_tasks_abstract.provider import Task
+
 from codee import executor, tasks_providers
 from codee.lib import runs_db
+from codee.lib.trigger_issue_skills import IssueTriggeredSkill
 
 
 class RefreshConfigTest(unittest.TestCase):
@@ -414,3 +417,84 @@ class _Exploding:
 
 if __name__ == "__main__":
     unittest.main()
+
+
+def _polled_task(key: str, issue_type: str = "task",
+                 parent_type: str | None = None) -> Task:
+    """One task as a provider hands it over, optionally under a parent.
+
+    ``codee_work_item_types`` is what every provider fills in from the type
+    rows in Settings; here it stands for the default mapping, `story` pointed
+    at "Story" and `task` at "Task".
+    """
+    parent = None
+    if parent_type is not None:
+        parent = Task(key=f"{key}-parent", summary="The parent",
+                      status="Active", issue_type=parent_type.casefold(),
+                      priority="High", work_item_type=parent_type)
+    return Task(key=key, summary="Some work", status="Ready",
+                issue_type=issue_type, priority="High",
+                work_item_type=issue_type.capitalize(), parent=parent,
+                codee_work_item_types=frozenset({"story", "task"}))
+
+
+class ParentWorkItemSkipTest(unittest.TestCase):
+    """A poll leaves an item whose parent Codee polls to that parent's run."""
+
+    def setUp(self) -> None:
+        self.provider = Mock()
+        self.provider.is_configured.return_value = True
+        self.skills = [
+            IssueTriggeredSkill(name="Task developer", slug="task-developer",
+                                path=Path("/repo/.claude/skills/task/SKILL.md"),
+                                statuses=("Ready",), issue_type="task"),
+            IssueTriggeredSkill(name="Story developer", slug="story-developer",
+                                path=Path("/repo/.claude/skills/story/SKILL.md"),
+                                statuses=("Ready",), issue_type="story"),
+        ]
+        for name in ("trigger_cron_skills", "trigger_aws_sqs_skills",
+                     "trigger_email_skills", "_refresh_config"):
+            patcher = patch.object(executor, name)
+            self.addCleanup(patcher.stop)
+            patcher.start()
+        for name, result in (("_pull_latest_code", True),
+                             ("_load_sessions", {}),
+                             ("find_issue_triggered_skills", self.skills)):
+            patcher = patch.object(executor, name, return_value=result)
+            self.addCleanup(patcher.stop)
+            patcher.start()
+        provider = patch.object(executor, "tasks_provider", self.provider)
+        self.addCleanup(provider.stop)
+        provider.start()
+
+    def _submitted(self, *tasks: Task) -> list[str]:
+        """The task ids a poll over ``tasks`` actually launched an agent for."""
+        self.provider.get_tasks.return_value = list(tasks)
+        with patch.object(executor, "_submit_task") as submit:
+            executor.run_once()
+        return [call.args[0] for call in submit.call_args_list]
+
+    def test_an_item_under_a_mapped_parent_is_left_to_that_parents_run(self) -> None:
+        self.assertEqual(
+            self._submitted(_polled_task("NIM-1", parent_type="Story")), [])
+
+    def test_a_parent_mapped_to_any_work_item_counts(self) -> None:
+        # Not only the story: a task under a task is worked by the parent's
+        # own run just the same.
+        self.assertEqual(
+            self._submitted(_polled_task("NIM-2", parent_type="Task")), [])
+
+    def test_a_story_under_a_mapped_parent_is_skipped_too(self) -> None:
+        # The rule is about the parent, not about what the child is.
+        self.assertEqual(
+            self._submitted(_polled_task("NIM-3", issue_type="story",
+                                         parent_type="Story")), [])
+
+    def test_an_item_under_an_unmapped_parent_is_worked(self) -> None:
+        # An Epic is nothing Codee polls, so nothing else will do this work.
+        self.assertEqual(
+            self._submitted(_polled_task("NIM-4", parent_type="Epic")),
+            ["NIM-4"])
+
+    def test_an_item_with_no_parent_is_worked(self) -> None:
+        self.assertEqual(self._submitted(_polled_task("NIM-5")), ["NIM-5"])

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_agent_claude_code/provider.py

@@ -14,6 +14,7 @@ log = get_logger(__name__)
 # maintained by hand. It only feeds the admin UI's picker — the editor also takes
 # a model id typed by hand, so a model missing here is still usable.
 MODELS = [
+    AgentModel("claude-opus-5-5", "Claude Opus 5.5"),
     AgentModel("claude-opus-5", "Claude Opus 5"),
     AgentModel("claude-sonnet-5", "Claude Sonnet 5"),
     AgentModel("claude-fable-5-1", "Claude Fable 5.1"),

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_agent_claude_code/test.py

@@ -74,6 +74,11 @@ class ClaudeCodeRunTest(unittest.TestCase):
         # The alias tracks the newest Opus, so no release needs an edit here.
         self.assertEqual(ClaudeCodeAgent.best_model(), "opus")
 
+    def test_opus_5_5_is_available_in_the_model_catalog(self) -> None:
+        models = [(model.id, model.name) for model in self.agent.list_models()]
+
+        self.assertIn(("claude-opus-5-5", "Claude Opus 5.5"), models)
+
 
 class ClaudeCodeUsageTest(unittest.TestCase):
     """Reading a subscription's remaining allowance out of the usage response."""

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_tasks_abstract/provider.py

@@ -29,17 +29,38 @@ class Task:
     priority: str
     labels: list[str] = field(default_factory=list)
     parent: "Task | None" = None
+    # What the backend itself calls this item's type ("User Story", "Bug"), as
+    # opposed to ``issue_type``, which carries the Codee work item it was
+    # polled as. Both are kept because the mapping between them is lossy in
+    # both directions: a type Codee was never pointed at passes through
+    # unmapped and may collide with a Codee name by accident, and a work item
+    # found by a query of the user's own is named by that query rather than by
+    # any type at all.
+    work_item_type: str = ""
+    # Every backend type this installation pointed a Codee work item at,
+    # case-folded. Empty for a provider with no such mapping, which is what
+    # leaves ``is_parent_codee_work_item`` answering "no" for it.
+    codee_work_item_types: frozenset[str] = frozenset()
 
     @property
-    def is_parent_codee_story(self) -> bool:
-        """Whether this task hangs under a story Codee owns.
-
-        What marks a story as Codee-owned is provider-specific — a label in
-        JIRA, a work item type in Azure DevOps — so each provider answers this
-        for its own tasks. The executor only asks the question. A provider that
-        has no notion of Codee stories inherits "no parent story".
+    def is_parent_codee_work_item(self) -> bool:
+        """Whether this item hangs under one Codee polls in its own right.
+
+        A parent of a mapped type gets its own agent run, and that run is what
+        decides what its children need — so the child is left alone here
+        rather than worked a second time beside it. Whatever state the parent
+        rests in, and whether or not the poll itself returned it, the answer is
+        the same one its type gives.
+
+        Only types answer it. A work item the user selects with a query of
+        their own (JQL, WIQL) names no type, and nothing in a parent says
+        whether that condition would have claimed it — so such a work item
+        shields nothing, and its children are polled on their own terms.
         """
-        return False
+        parent = self.parent
+        if parent is None or not parent.work_item_type:
+            return False
+        return parent.work_item_type.casefold() in self.codee_work_item_types
 
 
 def merge_work_item_tasks(results: list[list["Task"]]) -> list["Task"]:

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_tasks_azure_devops/provider.py

@@ -9,8 +9,8 @@ from urllib.parse import quote
 
 import requests
 from codee_main_context.context import (
-    CodeeMainContext, STORY_ISSUE_TYPE, Settings, TASK_ISSUE_TYPE,
-    TasksProvider, WorkItemMapping, codee_work_items, data_dir, task_filter,
+    CodeeMainContext, Settings, TASK_ISSUE_TYPE, TasksProvider,
+    WorkItemMapping, codee_work_items, data_dir, task_filter,
     work_item_mappings)
 from codee_main_context.logging import get_logger
 from codee_tasks_abstract.provider import (
@@ -70,7 +70,7 @@ _TIMEOUT = 30
 
 def _describe_task(task: Task) -> str:
     """One work item as a log fragment: what it is and what Codee decided it is."""
-    raw = getattr(task, "work_item_type", "")
+    raw = task.work_item_type
     mapped = f"{raw}->{task.issue_type}" if raw != task.issue_type else task.issue_type
     return f"{task.key} [{task.status}/{mapped}]"
 
@@ -98,46 +98,6 @@ def _describe_error(exc: requests.RequestException) -> str:
         f": {detail[:300]}" if detail else "")
 
 
-class AzureDevOpsWorkItem(Task):
-    """A Task that remembers the raw Azure DevOps work item type.
-
-    ``issue_type`` carries the mapped Codee name, and that mapping is lossy in
-    both directions: a type Codee was never pointed at passes through unmapped
-    and may collide with a Codee name by accident. Comparing the raw type
-    against ``story_work_item_types`` — the backend types this installation
-    mapped its story to — is what keeps that accident from reading as a real
-    Codee story.
-    """
-
-    def __init__(self, work_item_type: str = "",
-                 story_work_item_types: list[str] | None = None,
-                 story_keys: frozenset[str] | set[str] = frozenset(),
-                 **kwargs):
-        self.work_item_type = work_item_type
-        self.story_work_item_types = list(story_work_item_types or [])
-        self.story_keys = story_keys
-        super().__init__(**kwargs)
-
-    @property
-    def is_parent_codee_story(self) -> bool:
-        """In Azure DevOps a Codee-owned story is a type mapped to "story".
-
-        Or, where the story is selected by a WIQL condition instead of a type
-        list, a parent that condition claims — which the provider establishes
-        by putting the condition to Azure DevOps with this page's parent ids.
-        Whatever state the story is resting in, and whether or not the poll
-        itself returned it, the answer is the same one its type would have
-        given.
-        """
-        parent = self.parent
-        if not isinstance(parent, AzureDevOpsWorkItem):
-            return False
-        if parent.key in self.story_keys:
-            return True
-        return parent.work_item_type.casefold() in {
-            story_type.casefold() for story_type in self.story_work_item_types}
-
-
 class AzureDevOpsTasksProvider(AbstractTasksProvider):
     """Fetches the organization's Codee work items as provider-agnostic Tasks."""
 
@@ -158,8 +118,12 @@ class AzureDevOpsTasksProvider(AbstractTasksProvider):
         self._work_items = work_item_mappings(
             settings, TasksProvider.AZURE_DEVOPS)
         self._codee_types = codee_work_items(self._work_items)
-        self._story_work_item_types = list(self._work_item(
-            STORY_ISSUE_TYPE).types)
+        # The same mapping read as a set of backend types: a work item whose
+        # parent is one of them is left to that parent's own run. Only the
+        # types are in it — ``codee_work_items`` leaves out the work items
+        # selected by a WIQL condition, which is also what the executor's rule
+        # is defined in terms of.
+        self._codee_parent_types = frozenset(self._codee_types)
         # An extra WIQL condition the user narrowed the poll with, empty unless
         # one was configured. Kept as written: it is theirs to get right, and
         # Azure DevOps explains a rejected query better than a parser here could.
@@ -399,11 +363,9 @@ class AzureDevOpsTasksProvider(AbstractTasksProvider):
         # The batch endpoint doesn't preserve the WIQL ordering, so each work
         # item's tasks are rebuilt in the order its own query asked for.
         by_id = {item["id"]: item for item in items}
-        story_keys = self._codee_story_parents(token, parents, raise_errors)
         results = []
         for mapping, found in ids_by_work_item:
-            tasks = [self._to_task(by_id[item_id], parents, mapping.name,
-                                   story_keys)
+            tasks = [self._to_task(by_id[item_id], parents, mapping.name)
                      for item_id in found if item_id in by_id]
             log.debug("WIQL for work item %s matched %d work item(s)%s",
                       mapping.name, len(tasks),
@@ -412,48 +374,6 @@ class AzureDevOpsTasksProvider(AbstractTasksProvider):
             results.append(tasks)
         return merge_work_item_tasks(results)
 
-    def _codee_story_parents(self, token: str, parents: dict[int, dict],
-                             raise_errors: bool) -> set[str]:
-        """Which of this page's parents are stories Codee owns.
-
-        A child of one is driven by the story's own agent run, so the executor
-        has to be told which parents those are. Where the story work item names
-        types, the parent's own type answers it and nothing is asked. Where it
-        is selected by a condition, the condition is put to Azure DevOps with
-        the parents' ids — one query for the whole page, not one per parent,
-        and no state clause: a story shields its children whatever state it is
-        resting in, exactly as its type would have.
-
-        When that query fails, every parent is treated as a story. A tick that
-        does too little is caught by the next one; a child worked beside the
-        story that is already working it is two agents on one change.
-        """
-        story = self._work_item(STORY_ISSUE_TYPE)
-        if not (story.is_query and parents):
-            return set()
-        ids = ", ".join(str(parent_id) for parent_id in sorted(parents))
-        query = ("SELECT [System.Id] FROM WorkItems "
-                 f"WHERE ({story.query}) AND [System.Id] IN ({ids})")
-        log.debug("WIQL for the parents of this page: %s", query)
-        try:
-            response = requests.post(
-                f"{self._config.organization_url}/_apis/wit/wiql",
-                params={"api-version": API_VERSION, "$top": _MAX_TASKS},
-                json={"query": query},
-                headers=self._headers(token),
-                timeout=_TIMEOUT,
-            )
-            response.raise_for_status()
-        except requests.RequestException as exc:
-            if raise_errors:
-                raise TasksProviderError(_describe_error(exc)) from exc
-            log.error("Azure DevOps could not say which parents are stories, "
-                      "so their children wait for the next poll: %s",
-                      _describe_error(exc))
-            return {str(parent_id) for parent_id in parents}
-        return {str(item["id"])
-                for item in response.json().get("workItems") or []}
-
     def _work_item_ids(self, token: str, mapping: WorkItemMapping,
                        statuses: list[str], raise_errors: bool) -> list[int]:
         """The ids one Codee work item's query returned, in its own order.
@@ -604,26 +524,20 @@ class AzureDevOpsTasksProvider(AbstractTasksProvider):
                 "Accept": "application/json"}
 
     def _to_task(self, item: dict, parents: dict[int, dict],
-                 issue_type: str = "",
-                 story_keys: frozenset[str] | set[str] = frozenset()) -> Task:
+                 issue_type: str = "") -> Task:
         """One work item as the executor reads it.
 
         ``issue_type`` is the Codee work item whose query returned it, which is
         the only thing that can name an item a custom condition matched. Left
         out for a parent, which no query asked for: it falls back to whichever
         work item claims the type Azure DevOps gave it.
-
-        ``story_keys`` are the parents established as Codee stories, which is
-        how a child of a story selected by a custom condition is still
-        recognized as one — its type alone cannot say so.
         """
         fields = item.get("fields", {})
         parent = parents.get(fields.get("System.Parent"))
         work_item_type = fields.get("System.WorkItemType", "")
-        return AzureDevOpsWorkItem(
+        return Task(
             work_item_type=work_item_type,
-            story_work_item_types=self._story_work_item_types,
-            story_keys=story_keys,
+            codee_work_item_types=self._codee_parent_types,
             key=str(item["id"]),
             summary=fields.get("System.Title", ""),
             status=fields.get("System.State", ""),

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_tasks_azure_devops/test.py

@@ -422,9 +422,9 @@ class TasksProviderTest(unittest.TestCase):
 
         self.assertEqual(tasks[0].issue_type, "task")
 
-    def test_a_child_of_any_mapped_story_type_is_flagged(self) -> None:
-        # Both types are the story this installation drives its children from,
-        # so a child of either has to be left to the story's own run.
+    def test_a_child_of_any_mapped_type_is_flagged(self) -> None:
+        # Every type a row names is polled in its own right, so a child of any
+        # of them is left to the run the parent gets.
         settings = _settings(organization_url="https://dev.azure.com/acme",
                              client_id="client-1", client_secret="secret-1")
         settings.work_item_types = {"azure_devops": {
@@ -434,7 +434,7 @@ class TasksProviderTest(unittest.TestCase):
 
         tasks = self._tasks_with_parent_type("Feature")
 
-        self.assertTrue(tasks[0].is_parent_codee_story)
+        self.assertTrue(tasks[0].is_parent_codee_work_item)
 
     def test_a_work_item_with_a_query_is_asked_for_in_its_own_words(self) -> None:
         # The advanced answer: what a `bug` is cannot be said with type names
@@ -497,91 +497,26 @@ class TasksProviderTest(unittest.TestCase):
         self.provider = AzureDevOpsTasksProvider(settings, self.context)
         self._connect()
 
-    def test_a_child_of_a_queried_story_is_flagged(self) -> None:
-        # A story picked out by a condition has no type to recognize it by, so
-        # the condition is put to Azure DevOps with this page's parent ids.
+    def test_a_work_item_selected_by_wiql_shields_nothing(self) -> None:
+        # Nothing in a parent says whether the condition would have claimed it,
+        # so a work item written as WIQL takes no child out of the poll. Only
+        # the types a row names do that.
         self._queried_story_provider()
 
-        tasks = self._tasks_with_parent_type("Feature", story_parents=[30])
-
-        self.assertTrue(tasks[0].is_parent_codee_story)
-
-    def test_a_queried_story_shields_its_children_in_any_state(self) -> None:
-        # The parent is a story the poll itself never saw — it rests in a state
-        # no skill triggers on — and its children are still its own to drive,
-        # exactly as a story named by its type would be.
-        self._queried_story_provider()
-
-        tasks = self._tasks_with_parent_type(
-            "Feature", story_ids=[], story_parents=[30])
-
-        self.assertTrue(tasks[0].is_parent_codee_story)
-
-    def test_a_parent_the_story_condition_rejects_is_not_flagged(self) -> None:
-        self._queried_story_provider()
-
-        tasks = self._tasks_with_parent_type("Feature", story_parents=[])
-
-        self.assertFalse(tasks[0].is_parent_codee_story)
-
-    def test_the_parent_query_asks_only_about_this_page_s_parents(self) -> None:
-        self._queried_story_provider()
-        items = _response({"value": [
-            {"id": 31, "fields": {"System.Title": "A child",
-                                  "System.State": "Ready",
-                                  "System.WorkItemType": "Task",
-                                  "System.Parent": 30}},
-        ]})
-        parents = _response({"value": [
-            {"id": 30, "fields": {"System.Title": "The parent",
-                                  "System.State": "Done",
-                                  "System.WorkItemType": "Feature"}},
-        ]})
-
-        with patch("codee_tasks_azure_devops.provider.requests.post",
-                   side_effect=[*_wiql_results([], [31]), items, parents,
-                                *_wiql_results([30])]) as post:
-            self.provider.get_tasks(["Ready"])
+        tasks = self._tasks_with_parent_type("Feature")
 
-        query = post.call_args_list[-1].kwargs["json"]["query"]
-        self.assertIn("([System.Tags] CONTAINS 'codee-story')", query)
-        self.assertIn("[System.Id] IN (30)", query)
-        # No state clause: a story shields its children whatever state it is in.
-        self.assertNotIn("[System.State]", query)
+        self.assertFalse(tasks[0].is_parent_codee_work_item)
 
-    def test_a_types_story_asks_nothing_extra_about_its_parents(self) -> None:
-        # The parent's own type is already in hand, so the question is free.
+    def test_nothing_extra_is_asked_about_the_parents(self) -> None:
+        # A parent's own type comes back with it, so the answer costs no
+        # request of its own: one query per work item, the batch read of what
+        # they found, and one more for their parents.
         self._connect()
-        tasks = self._tasks_with_parent_type("User Story")
 
-        self.assertTrue(tasks[0].is_parent_codee_story)
-
-    def test_children_wait_when_the_parent_query_fails(self) -> None:
-        # A tick that does too little is caught by the next one; a child worked
-        # beside the story already working it is two agents on one change.
-        self._queried_story_provider()
-        items = _response({"value": [
-            {"id": 31, "fields": {"System.Title": "A child",
-                                  "System.State": "Ready",
-                                  "System.WorkItemType": "Task",
-                                  "System.Parent": 30}},
-        ]})
-        parents = _response({"value": [
-            {"id": 30, "fields": {"System.Title": "The parent",
-                                  "System.State": "Done",
-                                  "System.WorkItemType": "Feature"}},
-        ]})
-        rejected = Mock(status_code=400, text="")
-        rejected.json.return_value = {"message": "TF51005: no such field."}
-        rejected.raise_for_status.side_effect = requests.HTTPError(
-            "400 Client Error", response=rejected)
-
-        with patch("codee_tasks_azure_devops.provider.requests.post",
-                   side_effect=[*_wiql_results([], [31]), items, parents,
-                                rejected]):
-            tasks = self.provider.get_tasks(["Ready"])
+        tasks = self._tasks_with_parent_type("User Story")
 
-        self.assertTrue(tasks[0].is_parent_codee_story)
+        self.assertTrue(tasks[0].is_parent_codee_work_item)
+        self.assertEqual(self.post.call_count, 4)
 
     def test_work_items_are_interleaved_rather_than_concatenated(self) -> None:
         # Each query is priority-ordered on its own, and nothing orders them
@@ -744,20 +679,29 @@ class TasksProviderTest(unittest.TestCase):
 
         self.assertEqual(tasks[0].issue_type, "story")
 
-    def test_a_child_of_a_codee_story_is_flagged(self) -> None:
+    def test_a_child_of_a_mapped_parent_type_is_flagged(self) -> None:
         self._connect()
         tasks = self._tasks_with_parent_type("User Story")
 
-        self.assertTrue(tasks[0].is_parent_codee_story)
+        self.assertTrue(tasks[0].is_parent_codee_work_item)
+
+    def test_a_child_of_a_mapped_task_type_is_flagged_too(self) -> None:
+        # The rule is not about stories: a Task under a Task is worked inside
+        # the parent's own run just the same.
+        self._connect()
+
+        tasks = self._tasks_with_parent_type("Task")
+
+        self.assertTrue(tasks[0].is_parent_codee_work_item)
 
-    def test_a_child_of_an_unmapped_story_type_is_not_flagged(self) -> None:
+    def test_a_child_of_an_unmapped_parent_type_is_not_flagged(self) -> None:
         self._connect()
-        # "Story" is not the type this installation mapped its story to, and
+        # "Story" is not a type this installation pointed a work item at, and
         # the accidental collision with the Codee name must not read as one.
         tasks = self._tasks_with_parent_type("Story")
 
         self.assertEqual(tasks[0].parent.issue_type, "Story")
-        self.assertFalse(tasks[0].is_parent_codee_story)
+        self.assertFalse(tasks[0].is_parent_codee_work_item)
 
     def test_a_task_without_a_parent_is_not_flagged(self) -> None:
         self._connect()
@@ -771,16 +715,14 @@ class TasksProviderTest(unittest.TestCase):
                    side_effect=[*_wiql_results([], [31]), items]):
             tasks = self.provider.get_tasks(["Ready"])
 
-        self.assertFalse(tasks[0].is_parent_codee_story)
+        self.assertFalse(tasks[0].is_parent_codee_work_item)
 
     def _tasks_with_parent_type(self, parent_type: str,
-                                story_ids: list[int] | None = None,
-                                story_parents: list[int] | None = None) -> list:
+                                story_ids: list[int] | None = None) -> list:
         """One task under one parent, as a poll returns it.
 
-        ``story_parents`` is what the extra query answers when the story work
-        item is selected by a condition: which of this page's parents it
-        claims. Left out where the story names types, since nothing is asked.
+        The mock it ran against is left on ``self.post``, for the tests that
+        care what answering the parent cost.
         """
         items = _response({"value": [
             {"id": 31, "fields": {"System.Title": "A child",
@@ -794,11 +736,10 @@ class TasksProviderTest(unittest.TestCase):
                                   "System.WorkItemType": parent_type}},
         ]})
 
-        responses = [*_wiql_results(story_ids or [], [31]), items, parents]
-        if story_parents is not None:
-            responses.extend(_wiql_results(story_parents))
         with patch("codee_tasks_azure_devops.provider.requests.post",
-                   side_effect=responses):
+                   side_effect=[*_wiql_results(story_ids or [], [31]),
+                                items, parents]) as post:
+            self.post = post
             return self.provider.get_tasks(["Ready"])
 
     def test_empty_result_skips_the_batch_call(self) -> None:

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_tasks_jira/provider.py

@@ -1,4 +1,3 @@
-from typing import Callable
 from urllib.parse import quote
 
 import requests
@@ -14,10 +13,6 @@ from codee_tasks_abstract.provider import (
 
 log = get_logger(__name__)
 
-# The label that marks a JIRA story as Codee-owned. Children of such a story
-# are driven by the story's own agent run, so the executor leaves them alone.
-CODEE_STORY_LABEL = "CodeeStory"
-
 # Atlassian's own MCP server, run straight from PyPI through `uvx` so the only
 # thing that has to exist on the machine is uv — no install step to keep in sync
 # with the credentials below.
@@ -57,43 +52,6 @@ def _describe_error(exc: requests.RequestException) -> str:
         f": {detail[:300]}" if detail else "")
 
 
-class JiraTask(Task):
-    """A JIRA task whose labels are fetched the first time they're read.
-
-    A parent reference in the search response carries no labels, so resolving
-    them eagerly would cost an extra request per tick even when the caller
-    never inspects them. Deferring the fetch keeps the common path request-free;
-    the result is cached so repeated reads don't re-fetch.
-    """
-
-    def __init__(self, labels_loader: Callable[[], list[str]] | None = None, **kwargs):
-        self._labels_loader = labels_loader
-        self._resolved_labels: list[str] | None = None
-        super().__init__(**kwargs)
-
-    @property
-    def labels(self) -> list[str]:
-        if self._resolved_labels is None:
-            if self._raw_labels is not None:
-                self._resolved_labels = self._raw_labels
-            elif self._labels_loader is not None:
-                self._resolved_labels = self._labels_loader()
-            else:
-                self._resolved_labels = []
-        return self._resolved_labels
-
-    @labels.setter
-    def labels(self, value: list[str] | None) -> None:
-        # Set by Task.__init__; None means "not present in the response".
-        self._raw_labels = value
-
-    @property
-    def is_parent_codee_story(self) -> bool:
-        """In JIRA a Codee-owned story is marked with the CodeeStory label."""
-        return (self.parent is not None
-                and CODEE_STORY_LABEL in self.parent.labels)
-
-
 class JiraTasksProvider(AbstractTasksProvider):
     """Fetches AI-owned issues from JIRA and maps them to provider-agnostic Tasks."""
 
@@ -116,6 +74,12 @@ class JiraTasksProvider(AbstractTasksProvider):
         # query asked for — a parent is fetched without a type filter.
         self._work_items = work_item_mappings(settings, TasksProvider.JIRA)
         self._codee_types = codee_work_items(self._work_items)
+        # The same mapping read as a set of backend types: an issue whose
+        # parent is one of them is left to that parent's own run. Only the
+        # types are in it — ``codee_work_items`` leaves out the work items
+        # selected by a JQL condition, which is also what the executor's rule
+        # is defined in terms of.
+        self._codee_parent_types = frozenset(self._codee_types)
         # An extra JQL condition the user narrowed the poll with, empty unless
         # one was configured. Kept as written: it is theirs to get right, and
         # JIRA says what is wrong with it far better than a parser here could.
@@ -397,12 +361,14 @@ class JiraTasksProvider(AbstractTasksProvider):
         """
         fields = issue.get("fields", {})
         parent_issue = fields.get("parent")
-        return JiraTask(
+        jira_type = fields.get("issuetype", {}).get("name", "")
+        return Task(
             key=issue["key"],
             summary=fields.get("summary", ""),
             status=fields.get("status", {}).get("name", ""),
-            issue_type=issue_type or self._codee_issue_type(
-                fields.get("issuetype", {}).get("name", "")),
+            work_item_type=jira_type,
+            codee_work_item_types=self._codee_parent_types,
+            issue_type=issue_type or self._codee_issue_type(jira_type),
             priority=(fields.get("priority") or {}).get("name", "Unknown"),
             labels=fields.get("labels") or [],
             parent=self._to_parent_task(
@@ -410,33 +376,21 @@ class JiraTasksProvider(AbstractTasksProvider):
         )
 
     def _to_parent_task(self, parent_issue: dict) -> Task:
-        # Labels aren't included for a parent, so defer the fetch until read.
-        key = parent_issue["key"]
+        """The issue above a Codee one, out of the reference JIRA inlined.
+
+        Costs no request: a search response carries the parent's own fields,
+        including the type that decides whether this issue is left to the
+        parent's run. Its own parent is not resolved — the executor looks one
+        level up, and the reference carries no grandparent anyway.
+        """
         fields = parent_issue.get("fields", {})
-        return JiraTask(
-            key=key,
+        jira_type = fields.get("issuetype", {}).get("name", "")
+        return Task(
+            key=parent_issue["key"],
             summary=fields.get("summary", ""),
             status=fields.get("status", {}).get("name", ""),
-            issue_type=self._codee_issue_type(
-                fields.get("issuetype", {}).get("name", "")),
+            work_item_type=jira_type,
+            issue_type=self._codee_issue_type(jira_type),
             priority=(fields.get("priority") or {}).get("name", "Unknown"),
-            labels=fields.get("labels"),
-            labels_loader=lambda: self._fetch_issue_labels(key),
+            labels=fields.get("labels") or [],
         )
-
-    def _fetch_issue_labels(self, issue_key: str) -> list[str]:
-        """Fetch labels for a single JIRA issue."""
-        url = f"{self._base_url}/rest/api/3/issue/{issue_key}"
-        try:
-            resp = requests.get(
-                url,
-                params={"fields": "labels"},
-                auth=(self._user_email, self._api_token),
-                headers={"Accept": "application/json"},
-                timeout=30,
-            )
-            resp.raise_for_status()
-            return resp.json().get("fields", {}).get("labels", [])
-        except requests.RequestException as exc:
-            log.error("Failed to fetch labels for %s: %s", issue_key, exc)
-            return []

{codee_agent-0.6.3 → codee_agent-0.6.4}/src/codee_tasks_jira/test.py

@@ -26,12 +26,13 @@ def _configure(provider: JiraTasksProvider,
                   else work_item_mappings(Settings()))
     provider._work_items = work_items
     provider._codee_types = codee_work_items(work_items)
+    provider._codee_parent_types = frozenset(provider._codee_types)
     provider._task_filter = ""
     return provider
 
 
-def _issue(key: str = "CORE-1",
-           parent_labels: list[str] | None = None) -> dict:
+def _issue(key: str = "CORE-1", parent_type: str | None = None) -> dict:
+    """One search result, hanging under a parent of ``parent_type`` if given."""
     issue = {"key": key, "fields": {
         "summary": "A task",
         "status": {"name": "Ready"},
@@ -39,48 +40,72 @@ def _issue(key: str = "CORE-1",
         "priority": {"name": "High"},
         "labels": [],
     }}
-    if parent_labels is not None:
+    if parent_type is not None:
         issue["fields"]["parent"] = {
             "key": "CORE-9",
             "fields": {"summary": "A story",
                        "status": {"name": "In Progress"},
-                       "issuetype": {"name": "Story"},
-                       "labels": parent_labels},
+                       "issuetype": {"name": parent_type},
+                       "labels": ["backend"]},
         }
     return issue
 
 
-class JiraParentStoryTest(unittest.TestCase):
+class JiraParentWorkItemTest(unittest.TestCase):
+    """Which issues are left to the run of the issue above them."""
+
     def setUp(self) -> None:
         self.provider = _configure(
             JiraTasksProvider.__new__(JiraTasksProvider))
 
-    def test_parent_with_the_label_is_a_codee_story(self) -> None:
-        task = self.provider._to_task(_issue(parent_labels=["CodeeStory", "backend"]))
+    def test_a_parent_of_a_mapped_type_is_a_codee_work_item(self) -> None:
+        task = self.provider._to_task(_issue(parent_type="Story"))
+
+        self.assertTrue(task.is_parent_codee_work_item)
+
+    def test_a_parent_mapped_to_the_same_work_item_counts_too(self) -> None:
+        # Not only the story: a task under a task gets its work from the
+        # parent's own run just the same, whichever row selected the parent.
+        task = self.provider._to_task(_issue(parent_type="Task"))
+
+        self.assertTrue(task.is_parent_codee_work_item)
+
+    def test_a_parent_no_row_selects_is_not_one(self) -> None:
+        # An Epic above a Codee story is nothing Codee polls, so the issue
+        # under it is worked on its own.
+        task = self.provider._to_task(_issue(parent_type="Epic"))
 
-        self.assertTrue(task.is_parent_codee_story)
+        self.assertFalse(task.is_parent_codee_work_item)
 
-    def test_parent_without_the_label_is_not(self) -> None:
-        task = self.provider._to_task(_issue(parent_labels=["backend"]))
+    def test_the_type_is_matched_however_it_is_cased(self) -> None:
+        task = self.provider._to_task(_issue(parent_type="story"))
 
-        self.assertFalse(task.is_parent_codee_story)
+        self.assertTrue(task.is_parent_codee_work_item)
 
-    def test_a_task_with_no_parent_is_not(self) -> None:
+    def test_an_issue_with_no_parent_is_not(self) -> None:
         task = self.provider._to_task(_issue())
 
-        self.assertFalse(task.is_parent_codee_story)
+        self.assertFalse(task.is_parent_codee_work_item)
 
-    def test_labels_missing_from_the_parent_are_fetched_once(self) -> None:
-        parent = _issue(parent_labels=[])
-        del parent["fields"]["parent"]["fields"]["labels"]
-        task = self.provider._to_task(parent)
+    def test_a_work_item_selected_by_jql_shields_nothing(self) -> None:
+        # Nothing in a parent says whether the condition would have claimed it,
+        # so a work item written as JQL takes no children out of the poll.
+        provider = _configure(JiraTasksProvider.__new__(JiraTasksProvider),
+                              {"story": "labels = CodeeStory",
+                               "task": ["Task"]})
+
+        task = provider._to_task(_issue(parent_type="Story"))
 
-        with patch.object(self.provider, "_fetch_issue_labels",
-                          return_value=["CodeeStory"]) as fetch:
-            self.assertTrue(task.is_parent_codee_story)
-            self.assertTrue(task.is_parent_codee_story)
+        self.assertFalse(task.is_parent_codee_work_item)
 
-        fetch.assert_called_once_with("CORE-9")
+    def test_the_parent_comes_out_of_the_search_response(self) -> None:
+        # Its type is already inlined there, so the answer costs no request.
+        with patch("codee_tasks_jira.provider.requests.get") as get:
+            task = self.provider._to_task(_issue(parent_type="Story"))
+
+            self.assertTrue(task.is_parent_codee_work_item)
+        get.assert_not_called()
+        self.assertEqual(task.parent.key, "CORE-9")
 
 
 def _error(status: int, payload: dict | None = None) -> requests.HTTPError:
@@ -425,7 +450,7 @@ class JiraIssueTypeMappingTest(unittest.TestCase):
         provider = _configure(JiraTasksProvider.__new__(JiraTasksProvider),
                               {"story": ["Epic"], "task": ["Task"]})
 
-        task = provider._to_task(_issue(parent_labels=["backend"]))
+        task = provider._to_task(_issue(parent_type="Story"))
 
         self.assertEqual(task.parent.issue_type, "Story")