Merge remote-tracking branch 'origin/main' into item-429
CI / tests (pull_request) Has been cancelled

# Conflicts:
#	docs/reading-cost.md
This commit is contained in:
2026-11-18 20:32:49 +01:00
12 changed files with 240 additions and 32 deletions
+1
View File
@@ -2,6 +2,7 @@
## Unreleased
- do-epic's epic backends rank a child issue just before another, in Jira and in memory, and do-epic can re-rank Jira's backlog to an epic's ranking: it moves only the issues the loop filed, so each issue a person filed keeps its place, and it stops at the first rank Jira refuses and names it. Nothing calls it yet.
- Comprehension seats run as the `comprehension-seat` agent under `agents/`, which starts without `CLAUDE.md` and the skill and agent listings, and `larv-review prepare-scoring` no longer takes `--preloaded`; after updating, launch each seat with `subagent_type: comprehension-seat`.
- do-epic splits an epic item that changes several repos into one Jira sub-task per repo, each labelled `repo:<name>`, with a headless claude call predicting the repos from the code; the item is marked `split-by-repo` and counts as done once every sub-task is, and an issue a person filed gets a comment for the team in the epic's language. The epic backends gain `comment`, in the Jira backend and the in-memory one.
- do-epic's epic backends read each issue's scores, its blockers and whether the loop filed it, in the Jira backend and the in-memory one; the Jira backend marks each issue it files as the loop's. Nothing calls it yet.
+1 -1
View File
@@ -216,7 +216,7 @@ Install puts only `loop-claude` on `PATH`; call the others by their path, such a
- `branch_chunks/` cuts a default branch into chunks and finds, for each, the items it shipped and the later chunks that fixed its code, for `score_outcomes` and `routing_figures`. It imports `reading_cost`'s record path.
- `command_lines/` reads a shell command: its simple commands, and a docker call's subcommand and memory limits, for `command_patterns`, `reading_cost`, `routing_figures`, `rule_hook` and `run_heavy`.
- `deploy_release` imports `release_plan`'s `release_standing`.
- `do_epic/` will hold the tool that drives one Jira epic. So far `config.py` reads its machine-wide settings, importing `project_config`'s settings and `model_routing`'s ladder file, and `epic_record.py` reads and writes an epic's description by section and language line, through `record_store`'s `EpicDescription`. `repos.py` finds a repo's checkout and project config by its name, and clones a missing checkout from the host and owner of the epic's other repos, through `forge`'s `url_beside`. `repo_pick.py` asks claude, by `repo-rule.md`, where an epic item is worked, and records the answer as a label on the issue. `split.py` has claude predict from the code which repos an item changes, and files a sub-task per repo under it where there are several. `ranking.py` orders an epic's items by score over one chain of goals, the epic's, then code health, then the item's repo's, through `plan`'s ranking. `backend/` reads and files the epic's issues, adds the labels `repo_pick.py` and `split.py` record, and posts comments.
- `do_epic/` will hold the tool that drives one Jira epic. So far `config.py` reads its machine-wide settings, importing `project_config`'s settings and `model_routing`'s ladder file, and `epic_record.py` reads and writes an epic's description by section and language line, through `record_store`'s `EpicDescription`. `repos.py` finds a repo's checkout and project config by its name, and clones a missing checkout from the host and owner of the epic's other repos, through `forge`'s `url_beside`. `repo_pick.py` asks claude, by `repo-rule.md`, where an epic item is worked, and records the answer as a label on the issue. `split.py` has claude predict from the code which repos an item changes, and files a sub-task per repo under it where there are several. `ranking.py` orders an epic's items by score over one chain of goals, the epic's, then code health, then the item's repo's, through `plan`'s ranking, and re-ranks the tracker's backlog to that order through `backend/`. `backend/` reads, files and ranks the epic's issues, adds the labels `repo_pick.py` and `split.py` record, and posts comments.
- `forge/` tells a GitHub origin from a Gitea one, names a repo beside an origin's and runs that forge's CLI (`commands.py`), and finds a pull request and waits for its checks (`pulls.py`), for `chunk_preflight`, `chunk_pr`, `deploy_release`, `do_epic` and `larv_review`.
- `git_cli/` runs git for every tool (`git_repo.py`), and reads the git calls in a shell command (`git_command.py`).
- `judge_replay` imports `agent_cycle`'s judge and verdicts, and `loop_claude`'s premises, records and `ANSWER_DESTINATIONS`.
+9
View File
@@ -170,3 +170,12 @@ class EpicStoreContract:
task = self.filed(store, ours, "Count them in the api.")
read = {issue.key: issue for issue in self.issues(store)}
self.assertEqual([read[key].by_loop for key in (ours, theirs, task)], [True, False, True])
def test_ranks_a_child_issue_just_before_another_and_its_sub_tasks_follow_it(self) -> None:
store = self.new_store()
first, second, third = (self.filed(store, store.epic_key, f"Item {n}.") for n in range(3))
task = self.filed(store, third, "A task.")
self.assertEqual(store.rank(third, first), None)
self.assertEqual([issue.key for issue in self.issues(store)], [third, task, first, second])
self.assertEqual(store.rank(first, third), None)
self.assertEqual([issue.key for issue in self.issues(store)], [first, third, task, second])
+11 -1
View File
@@ -7,7 +7,7 @@ from failure import Failure
@dataclasses.dataclass
class MemoryEpic:
"""An epic whose issues rank in the order filed. Where fails is set, every read, filing, label and comment fails with it as the reason. comments holds each issue's comments, by key."""
"""An epic whose issues rank in the order filed, until one is ranked. Where fails is set, every read, filing, label, comment and rank fails with it as the reason. comments holds each issue's comments, by key."""
epic_key: str
issues: list[EpicIssue] = dataclasses.field(default_factory=list)
comments: dict[str, list[str]] = dataclasses.field(default_factory=dict)
@@ -40,6 +40,16 @@ class MemoryEpic:
self.change(key, labels=tuple(sorted({*child.labels, label})))
return None
def rank(self, key: str, before: str) -> None | Failure:
if self.fails:
return Failure(self.fails)
children = {issue.key: issue for issue in self.issues if issue.parent == self.epic_key}
if stray := next((each for each in (key, before) if each not in children), None):
return Failure(f"{stray} is not one of the child issues of the epic {self.epic_key}, so {key} is not ranked")
self.issues.remove(children[key])
self.issues.insert(self.issues.index(children[before]), children[key])
return None
def comment(self, key: str, text: str) -> None | Failure:
if self.fails:
return Failure(self.fails)
+8 -1
View File
@@ -5,7 +5,7 @@ import typing
from adf_codec.convert import adfs_to_markdown, markdown_to_adf, Refused
from atlassian.client import basic_auth, Http, jira_json, ToAdf, ToMarkdown
from plan_store.jira_epic import blocked_by_links, FILED_BY, ISSUE_KEY, ISSUE_TYPE, project_of, PROPERTY, scores, searched
from plan_store.jira_epic import blocked_by_links, FILED_BY, ISSUE_KEY, ISSUE_TYPE, project_of, PROPERTY, rank_refusal, scores, searched
from project_config.settings import Epic
from do_epic.backend.protocol import EpicIssue, no_child, no_parent, no_words, unfit, unfit_label
from failure import Failure
@@ -92,6 +92,13 @@ class JiraEpic:
edited = self.http("PUT", f"{self.epic.site}/rest/api/3/issue/{key}", authorization, {"update": {"labels": [{"add": label}]}})
return Failure(f"cannot label {key}: {edited.reason}") if isinstance(edited, Failure) else None
def rank(self, key: str, before: str) -> None | Failure:
authorization = basic_auth(self.env_file)
if isinstance(authorization, Failure):
return authorization
refused = rank_refusal(self.epic.site, key, before, authorization, self.http)
return Failure(refused) if refused else None
def comment(self, key: str, text: str) -> None | Failure:
authorization = basic_auth(self.env_file)
if isinstance(authorization, Failure):
+4 -1
View File
@@ -1,4 +1,4 @@
"""What every backend of an epic's plan reads, files and labels: an EpicIssue, and the EpicStore protocol they all meet. do-epic reads an epic only through EpicStore, so another tracker can stand behind it; contract.py holds the tests every backend passes.
"""What every backend of an epic's plan reads, files, labels, comments on and ranks: an EpicIssue, and the EpicStore protocol they all meet. do-epic reads an epic only through EpicStore, so another tracker can stand behind it; contract.py holds the tests every backend passes.
EpicStore is not plan_store's PlanStore. A PlanStore item names a release, but an epic item has none (`docs/decisions.md` → `do-epic: drives one Jira epic …`), and it may be a sub-task."""
import dataclasses
@@ -57,6 +57,9 @@ class EpicStore(typing.Protocol):
def add_label(self, key: str, label: str) -> None | Failure:
"""Adds label to the epic's child issue named key, leaving its other labels as they are; adding one it already has leaves the labels as they are. A sub-task, or an issue outside the epic, is refused."""
def rank(self, key: str, before: str) -> None | Failure:
"""Ranks the child issue named key just before the child issue named before. The sub-tasks of key follow key. Pass only keys of the epic's child issues, as read answers them: some backends don't check, and Jira ranks any issue it is given."""
def comment(self, key: str, text: str) -> None | Failure:
"""Posts text, markdown, as a comment on the epic's child issue named key, for the people who work the epic to read. A sub-task, an issue outside the epic, or an empty or blank text is refused."""
+9 -2
View File
@@ -38,10 +38,17 @@ class MemoryEpicContract(EpicStoreContract, unittest.TestCase):
class Failing(unittest.TestCase):
def test_every_read_filing_label_and_comment_fails_with_the_reason_given(self) -> None:
def test_every_read_filing_label_comment_and_rank_fails_with_the_reason_given(self) -> None:
store = MemoryEpic("ABC-12", fails="Jira is down")
down = Failure("Jira is down")
self.assertEqual((store.read(), store.file("ABC-12", "Count the runs.", "", ()), store.add_label("ABC-100", "api"), store.comment("ABC-100", "Hello.")), (down, down, down, down))
self.assertEqual((store.read(), store.file("ABC-12", "Count the runs.", "", ()), store.add_label("ABC-100", "api"), store.comment("ABC-100", "Hello."), store.rank("ABC-100", "ABC-101")), (down,) * 5)
class Ranking(unittest.TestCase):
def test_refuses_to_rank_beside_an_issue_that_isnt_a_child_of_the_epic(self) -> None:
store = MemoryEpic("ABC-12")
child = store.file("ABC-12", "Count the runs.", "", ())
self.assertEqual(store.rank(str(child), "ZZZ-1"), Failure(f"ZZZ-1 is not one of the child issues of the epic ABC-12, so {child} is not ranked"))
if __name__ == "__main__":
+26
View File
@@ -23,6 +23,7 @@ EPIC_URL = f"{SITE}/rest/api/3/issue/ABC-12?fields=summary"
ISSUE_TYPES = f"{SITE}/rest/api/3/issue/createmeta/ABC/issuetypes"
SEARCH = f"{SITE}/rest/api/3/search/jql"
ISSUES = f"{SITE}/rest/api/3/issue"
RANK = f"{SITE}/rest/agile/1.0/issue/rank"
TO_DO = {"name": "To Do", "statusCategory": {"key": "new"}}
TYPES = {"issueTypes": [{"id": "10001", "name": "Task", "subtask": False}, {"id": "10003", "name": "Subtask", "subtask": True}]}
@@ -60,6 +61,8 @@ class FakeJira:
return {"key": held["key"], "fields": {"parent": held["fields"]["parent"]}} # type: ignore[index]
if method == "POST" and url == ISSUES:
return self.created(body)
if method == "PUT" and url == RANK:
return self.ranked(body)
if method == "POST" and (held := next((issue for issue in self.issues if url == f"{ISSUES}/{issue['key']}/comment"), None)):
assert isinstance(body, dict)
self.comments.setdefault(str(held["key"]), []).append(body["body"])
@@ -92,6 +95,15 @@ class FakeJira:
self.issues.append({"key": key, "fields": {"summary": fields["summary"], "description": fields.get("description"), "labels": fields["labels"], "assignee": None, "status": TO_DO, "parent": {"key": parent}, "issuelinks": []}, "properties": {entry["key"]: entry["value"] for entry in body["properties"]}})
return {"id": "1", "key": key}
def ranked(self, body: object) -> object:
"""Moves the issue the body names to just before the other issue it names, and answers no body, as Jira does for a rank it made."""
assert isinstance(body, dict)
[key], before = body["issues"], body["rankBeforeIssue"]
moved = next(issue for issue in self.issues if issue["key"] == key)
self.issues.remove(moved)
self.issues.insert(next(place for place, issue in enumerate(self.issues) if issue["key"] == before), moved)
return None
def change(self, key: str, **fields: object) -> None:
next(issue for issue in self.issues if issue["key"] == key)["fields"].update(fields) # type: ignore[union-attr]
@@ -255,6 +267,20 @@ class Jira(Case):
store = JiraEpic(Epic(SITE, "ABC-99"), self.env_file, self.jira, to_markdown, to_adf)
self.assertEqual(store.read(), Failure(f"cannot read the epic ABC-99: Jira answered 404 for GET {SITE}/rest/api/3/issue/ABC-99?fields=summary"))
def test_a_rank_jira_refuses_fails_with_its_reason_and_ranks_nothing(self) -> None:
store = self.new_store()
first, second = (store.file("ABC-12", f"Item {n}.", "", ()) for n in range(2))
for answer, reason in (
(Failure("Jira answered 403"), "Jira answered 403"),
({"entries": [{"issueKey": second, "status": 400, "errors": ["Rank is not configured"]}]}, "Rank is not configured"),
):
with self.subTest(answer=answer):
self.jira.answers[("PUT", RANK)] = answer
self.assertEqual(store.rank(str(second), str(first)), Failure(reason))
read = store.read()
assert isinstance(read, list), read
self.assertEqual([issue.key for issue in read], [first, second])
if __name__ == "__main__":
unittest.main()
+49
View File
@@ -9,6 +9,7 @@ import decimal
from plan.blockers import blockers_first
from plan.todo_table import CODE_HEALTH, EPIC_GOAL, Item, REPO_GOAL, SHAPE
from do_epic.backend.protocol import EpicStore
from failure import Failure
from plan.goals_file import GOAL_STEP, goal_weights, Mark, numbered, ranked_goals
from review_rules.comprehension_history import latest_overall
@@ -59,6 +60,54 @@ def ranked(items: list[EpicItem], formula: str, epic_goals: str, repos: dict[str
return blockers_first(scored)
@dataclasses.dataclass(frozen=True)
class Rank:
"""One rank to ask of a tracker: the issue named key just before the issue named before."""
key: str
before: str
def reranked(store: EpicStore, order: list[str]) -> None | Failure:
"""Re-ranks the tracker's backlog so that the child issues whose keys order lists come in that sequence. Each key must name a child issue the loop filed, and only once; otherwise the call fails before it ranks any issue. The listed issues change positions only with each other: every other child issue, such as one a person filed, stays at its position in the backlog. A sub-task has no position of its own and follows its parent.
The first rank the tracker refuses ends the re-rank with a Failure that names it, since a wrongly ranked team backlog takes hours to restore; the ranks made before it stay."""
read = store.read()
if isinstance(read, Failure):
return read
children = [issue for issue in read if issue.parent == store.epic_key]
ours = {issue.key for issue in children if issue.by_loop}
if stray := next((key for key in order if key not in ours), None):
return Failure(f"{stray} is not one of the child issues of the epic {store.epic_key} that the loop filed, so the backlog was not re-ranked")
if twice := next((key for key in order if order.count(key) > 1), None):
return Failure(f"the order names {twice} twice, so the backlog was not re-ranked")
for rank in rank_moves([issue.key for issue in children], order):
if refused := store.rank(rank.key, rank.before):
return Failure(f"cannot rank {rank.key} just before {rank.before}: {refused.reason}; the re-rank stopped there, so rank the loop's issues in {store.epic_key}'s backlog by hand to come in this sequence: {', '.join(order)}")
return None
def rank_moves(backlog: list[str], order: list[str]) -> list[Rank]:
"""The ranks, in the sequence to make them, that turn backlog, a list of keys, into one where the keys order lists come in that sequence, each at a position one of them held, while every other key keeps its position. order names each key once, and each is in backlog.
Working from the backlog's end, a listed key that isn't already just before the key due after it ranks just before that key. The key due last, where it isn't already last, ranks just before the key that is, which moves away in its own turn, since it is due earlier."""
listed = set(order)
sequence = iter(order)
target = [next(sequence) if key in listed else key for key in backlog]
now = list(backlog)
ranks = []
for position in reversed(range(len(target))):
key = target[position]
due_after = target[position + 1] if position + 1 < len(target) else None
at = now.index(key)
if key not in listed or (now[at + 1] if at + 1 < len(now) else None) == due_after:
continue
rank = Rank(key, now[-1] if due_after is None else due_after)
ranks.append(rank)
now.remove(key)
now.insert(now.index(rank.before), key)
return ranks
def chain_scoring(formula: ast.Expression, epic_goals: str, repo: str | None, own: RepoRanking | None) -> ranking.Scoring | Failure:
"""How an item in repo scores: the chain's goals, and what each achieve goal weighs. The bar is 0, since a bar decides what is filed, and the order holds every item that was.
+110 -1
View File
@@ -1,14 +1,16 @@
import dataclasses
import decimal
import itertools
import pathlib
import sys
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from do_epic.ranking import chain, EpicItem, ranked, RepoRanking
from do_epic.ranking import chain, EpicItem, rank_moves, ranked, RepoRanking, reranked
from failure import Failure
from plan.todo_table import Item, parse_moves
from do_epic.backend.fake import MemoryEpic
EPIC_GOALS = "1. **Achieve:** Ship invoices.\n2. **Achieve:** Cut support mail.\n3. **Maintain:** Leak no customer data.\n"
VOIDED = RepoRanking("## Goals\n\n**Void:** code health, since it is a one-off script.\n\n1. **Achieve:** Fast builds.\n", "", "", decimal.Decimal("7.0"))
@@ -155,5 +157,112 @@ class RankedTest(unittest.TestCase):
self.assertIsInstance(order([item(1, "epic 1 by 9")], {"billing-api": VOIDED}, "V +"), Failure)
class Recording(MemoryEpic):
"""A MemoryEpic that keeps each rank asked of it, and refuses every rank of the issue named in refused."""
refused: str | None = None
asked: list[tuple[str, str]]
def rank(self, key: str, before: str) -> None | Failure:
self.asked.append((key, before))
return Failure("Jira answered 403") if key == self.refused else super().rank(key, before)
def epic(*people: int, issues: int = 4) -> Recording:
"""An epic whose child issues are ABC-100 onwards. The loop filed each of them, except those whose positions, counted from 0, are in people."""
store = Recording("ABC-12")
store.asked = []
for position in range(issues):
store.file("ABC-12", f"Item {position}.", "", ())
if position in people:
store.change(f"ABC-{100 + position}", by_loop=False)
return store
def keys(store: MemoryEpic) -> list[str]:
read = store.read()
assert isinstance(read, list), read
return [issue.key for issue in read]
class RerankedTest(unittest.TestCase):
def test_the_loops_issues_take_their_slots_in_the_order_given_and_a_persons_keep_theirs(self) -> None:
store = epic(1)
self.assertEqual(reranked(store, ["ABC-103", "ABC-100", "ABC-102"]), None)
self.assertEqual(keys(store), ["ABC-103", "ABC-101", "ABC-100", "ABC-102"])
def test_the_last_slot_takes_its_issue_where_a_persons_issue_comes_before_it(self) -> None:
store = epic(0, issues=3)
self.assertEqual(reranked(store, ["ABC-102", "ABC-101"]), None)
self.assertEqual(keys(store), ["ABC-100", "ABC-102", "ABC-101"])
def test_an_order_the_backlog_already_reads_in_ranks_nothing(self) -> None:
store = epic(1)
self.assertEqual(reranked(store, ["ABC-100", "ABC-102", "ABC-103"]), None)
self.assertEqual(store.asked, [])
def test_ranks_only_the_issues_out_of_place(self) -> None:
store = epic(issues=5)
self.assertEqual(reranked(store, ["ABC-100", "ABC-102", "ABC-101", "ABC-103", "ABC-104"]), None)
self.assertEqual(store.asked, [("ABC-101", "ABC-103")])
def test_an_issue_the_order_doesnt_name_keeps_its_slot(self) -> None:
store = epic()
store.change("ABC-101", status="Done", done=True)
self.assertEqual(reranked(store, ["ABC-103", "ABC-102", "ABC-100"]), None)
self.assertEqual(keys(store), ["ABC-103", "ABC-101", "ABC-102", "ABC-100"])
def test_sub_tasks_hold_no_slot_and_follow_their_parent(self) -> None:
store = epic(issues=2)
task = store.file("ABC-100", "A task.", "", ())
self.assertEqual(reranked(store, ["ABC-101", "ABC-100"]), None)
self.assertEqual(keys(store), ["ABC-101", "ABC-100", task])
def test_refuses_an_order_naming_a_persons_issue_a_sub_task_an_issue_outside_the_epic_or_one_twice(self) -> None:
store = epic(1)
task = store.file("ABC-100", "A task.", "", ())
for order, reason in (
(["ABC-101", "ABC-100"], "ABC-101 is not one of the child issues of the epic ABC-12 that the loop filed, so the backlog was not re-ranked"),
([task, "ABC-100"], f"{task} is not one of the child issues of the epic ABC-12 that the loop filed, so the backlog was not re-ranked"),
(["ZZZ-1"], "ZZZ-1 is not one of the child issues of the epic ABC-12 that the loop filed, so the backlog was not re-ranked"),
(["ABC-100", "ABC-102", "ABC-100"], "the order names ABC-100 twice, so the backlog was not re-ranked"),
):
with self.subTest(order=order):
self.assertEqual(reranked(store, order), Failure(reason))
self.assertEqual(store.asked, [])
def test_a_rank_the_tracker_refuses_stops_the_walk_and_names_the_order_to_finish_by_hand(self) -> None:
store = epic()
store.refused = "ABC-101"
self.assertEqual(reranked(store, ["ABC-103", "ABC-102", "ABC-101", "ABC-100"]), Failure("cannot rank ABC-101 just before ABC-100: Jira answered 403; the re-rank stopped there, so rank the loop's issues in ABC-12's backlog by hand to come in this sequence: ABC-103, ABC-102, ABC-101, ABC-100"))
self.assertEqual(store.asked, [("ABC-100", "ABC-103"), ("ABC-101", "ABC-100")])
def test_a_refused_rank_of_the_issue_due_last_names_it(self) -> None:
store = epic()
store.refused = "ABC-100"
self.assertEqual(reranked(store, ["ABC-103", "ABC-102", "ABC-101", "ABC-100"]), Failure("cannot rank ABC-100 just before ABC-103: Jira answered 403; the re-rank stopped there, so rank the loop's issues in ABC-12's backlog by hand to come in this sequence: ABC-103, ABC-102, ABC-101, ABC-100"))
def test_a_read_that_fails_ranks_nothing(self) -> None:
store = epic()
store.fails = "Jira is down"
self.assertEqual(reranked(store, ["ABC-101"]), Failure("Jira is down"))
self.assertEqual(store.asked, [])
class RankMovesTest(unittest.TestCase):
def test_every_backlog_of_up_to_six_issues_reaches_its_target_moving_only_the_listed_keys(self) -> None:
for size in range(7):
backlog = [f"K-{n}" for n in range(size)]
for listed in itertools.chain.from_iterable(itertools.combinations(backlog, count) for count in range(size + 1)):
for order in itertools.permutations(listed):
sequence = iter(order)
target = [next(sequence) if key in listed else key for key in backlog]
now = list(backlog)
for rank in rank_moves(backlog, list(order)):
self.assertIn(rank.key, listed)
now.remove(rank.key)
now.insert(now.index(rank.before), rank.key)
self.assertEqual(now, target, (backlog, order))
if __name__ == "__main__":
unittest.main()
+11 -10
View File
@@ -156,7 +156,7 @@ class JiraPlan:
notes.append(f"filed {key}, but cannot link it as blocked by {blocker}: {linked.reason}; link it in Jira")
if isinstance(before, Failure):
notes.append(f"filed {key}, but cannot rank it: {before.reason}; rank it in Jira")
elif before is not None and (refused := self.rank_refusal(key, before, authorization)):
elif before is not None and (refused := rank_refusal(self.epic.site, key, before, authorization, self.http)):
notes.append(f"filed {key}, but cannot rank it before {before}: {refused}; rank it in Jira")
return tuple(notes)
@@ -178,15 +178,6 @@ class JiraPlan:
notes.append(f"edited {issue.key}, but cannot delete the link that makes it blocked by {link.blocker}: {deleted.reason}; delete it in Jira")
return tuple(notes)
def rank_refusal(self, key: str, before: str, authorization: str) -> str | None:
"""Ranks the issue named key just before the issue named before; why Jira refused, or None where it didn't. Jira answers a rank it made with no body, and one it refused with an error, or with an entry per issue that holds the errors."""
answer = self.http("PUT", f"{self.epic.site}/rest/agile/1.0/issue/rank", authorization, {"issues": [key], "rankBeforeIssue": before})
if isinstance(answer, Failure):
return answer.reason
entries = answer.get("entries") if isinstance(answer, dict) else None
refused = [entry for entry in entries if isinstance(entry, dict) and entry.get("status") != 200] if isinstance(entries, list) else []
return "; ".join(str(error) for entry in refused for error in entry.get("errors") or [f"Jira answered {entry.get('status')}"]) or None
def fix_version(self, release: str, authorization: str) -> str | Failure:
"""The name of the Jira project's Fix Version for release, which a project may spell with a leading v, as `earliest_release` reads it."""
project = project_of(self.epic.key)
@@ -451,6 +442,16 @@ def children(epic: Epic, authorization: str, http: Http) -> list[object] | Failu
return searched(epic.site, f"{epic.key}'s children", f'parent = "{epic.key}" AND statusCategory != Done ORDER BY Rank ASC', {"fields": ["summary", "description", "fixVersions", "issuelinks"], "properties": [PROPERTY]}, authorization, http)
def rank_refusal(site: str, key: str, before: str, authorization: str, http: Http) -> str | None:
"""Ranks the issue named key just before the issue named before; why Jira refused, or None where it didn't. Jira answers a rank it made with no body, and one it refused with an error, or with an entry per issue that holds the errors."""
answer = http("PUT", f"{site}/rest/agile/1.0/issue/rank", authorization, {"issues": [key], "rankBeforeIssue": before})
if isinstance(answer, Failure):
return answer.reason
entries = answer.get("entries") if isinstance(answer, dict) else None
refused = [entry for entry in entries if isinstance(entry, dict) and entry.get("status") != 200] if isinstance(entries, list) else []
return "; ".join(str(error) for entry in refused for error in entry.get("errors") or [f"Jira answered {entry.get('status')}"]) or None
def searched(site: str, what: str, jql: str, asked: dict[str, object], authorization: str, http: Http) -> list[object] | Failure:
"""Every issue a JQL search on site finds, page by page. The dict asked holds the request's `fields` and `properties` lists. The text what names the issues sought, in the Failure of a search that doesn't end."""
body: dict[str, object] = {"jql": jql, "maxResults": PAGE} | asked
+1 -15
View File
@@ -12,8 +12,7 @@
| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 427 | 0.12.0 | | | **Re-rank Jira's backlog to match an epic's ranking, moving only the issues the loop filed, so people's issues keep their rank.** | 3 | 2 | 3 | 6 | 3 | 1 by 5 | 1.9 |
| 410 | 0.12.0 | 427 | | **Run `do-epic <EPIC-KEY>`: one tmux session per epic, a window per chunk, up to the epic's cap of running chunks and each repo's `parallel-chunks`, and never in a repo a loop-claude is running chunks in.** | 3 | 2 | 3 | 6 | 6 | 1 by 5 | 0.8 |
| 410 | 0.12.0 | | | **Run `do-epic <EPIC-KEY>`: one tmux session per epic, a window per chunk, up to the epic's cap of running chunks and each repo's `parallel-chunks`, and never in a repo a loop-claude is running chunks in.** | 3 | 2 | 3 | 6 | 6 | 1 by 5 | 0.8 |
| 416 | 0.12.0 | 410 | | **Finish an epic's repo item with a bullet under its repo's `CHANGELOG.md` → `## Unreleased`, or with none where the repo's plan is in Jira.** | 1 | 1 | 1 | 1 | 2 | 1 by 5 | 2.1 |
| 413 | 0.12.0 | 410 | | **File a finding about an epic goal in the epic and one about a repo goal by that repo's rules, ask the human where unsure which, and give the judge the epic's records beside the repo's.** | 3 | 2 | 3 | 6 | 4 | 1 by 5 | 1.6 |
| 415 | 0.12.0 | 410, 413 | | **Finish an epic: run release-review passes on each repo it changed, work what they file, have the human confirm each goal, post a summary comment, and close the epic in Jira last.** | 3 | 2 | 3 | 6 | 5 | 1 by 5 | 1.2 |
@@ -79,19 +78,6 @@
## Details
### 427. Re-rank Jira's backlog to match an epic's ranking, moving only the issues the loop filed, so people's issues keep their rank.
Split from item 408 (`docs/decisions.md` → `do-epic: drives one Jira epic …`). `EpicStore` gains a rank call, in both backends and the contract tests. Lift `JiraPlan.rank_refusal` to a module function both stores call. Walk the target order: where the issue at a position isn't the target's, rank the target's just before it; the slots people's issues hold stay theirs. A rank Jira refuses stops the walk and is reported, since a wrongly ranked team backlog takes hours to restore.
Touches:
- `bin/plan_store/jira_epic.py`: `JiraPlan.rank_refusal` (small)
- `bin/do_epic/backend/protocol.py`: `EpicStore` (small)
- `bin/do_epic/backend/fake.py`
- `bin/do_epic/backend/jira.py`
- `bin/do_epic/backend/contract.py`
- `bin/do_epic/ranking.py`
### 410. Run `do-epic <EPIC-KEY>`: one tmux session per epic, a window per chunk, up to the epic's cap of running chunks and each repo's `parallel-chunks`, and never in a repo a loop-claude is running chunks in.
The lock that keeps do-epic and loop-claude apart is the per-project `starting` flock, shared by both (`docs/decisions.md` → `do-epic: drives one Jira epic …`). Each chunk routes on its repo's model and ladder, a no-repo chunk on the machine setting's model. `loop/chunk_windows.py` `start_chunks` is a place the seats found hard: make it easier to read where it changes. Where a do-epic cycle's worker, judge or human reads the driver's name, they read do-epic, never loop-claude: item 401 left `agent_cycle`'s own text naming loop-claude, since whether the markers that code matches (`TYPED_HERE`, `TRANSCRIPT_HEADING`) vary by driver depends on what do-epic calls itself and where it archives its cycles. The worker's prompt and the judge's rules share the phrase a worker asks for a higher rung with, so both take it from one place.