From 426e03562f81aa2793c77e83550fdee408e68380 Mon Sep 17 00:00:00 2001
From: Peter Hense <peter.hense@gmail.com>
Date: Fri, 13 Nov 2026 12:04:57 +0000
Subject: [PATCH] fix(core): label managed issues with the bundling method's
 name

The issue label was hard-coded to engineering-method, so a Writing Method
backlog was labelled as Engineering Method work. The label now comes from
the method.json of the plugin that bundles Core; Core's own checkout and an
unreadable identity keep the historical name. The historical label stays
controlled, so an issue created under it is relabelled on the next
synchronization. Label descriptions name the method.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 engineering_method/issues.py     | 51 ++++++++++++++++++++++++--------
 tests/test_issues_regressions.py | 14 ++++-----
 tests/test_method_identity.py    | 34 +++++++++++++++++++++
 3 files changed, 80 insertions(+), 19 deletions(-)

diff --git a/engineering_method/issues.py b/engineering_method/issues.py
index 4282d01..c3c9096 100644
--- a/engineering_method/issues.py
+++ b/engineering_method/issues.py
@@ -31,17 +31,44 @@
     r"<!-- engineering-method:issue (?P<payload>\{[^\n]*\}) -->"
 )
 ISSUE_PREFIX = "<!-- engineering-method:issue "
-CONTROLLED_LABELS: tuple[tuple[str, str, str], ...] = (
-    ("engineering-method", "0B7285", "Managed by Peter's Engineering Method."),
-    ("priority:p0", "B60205", "Blocking or urgent work."),
-    ("priority:p1", "D93F0B", "Next planned work."),
-    ("priority:p2", "FBCA04", "Planned work."),
-    ("priority:p3", "C5DEF5", "Later improvement."),
-    ("status:open", "1D76DB", "Open Engineering Method work."),
-    ("status:in-progress", "5319E7", "Engineering Method work in progress."),
-    ("status:blocked", "B60205", "Engineering Method work currently blocked."),
-)
-CONTROLLED_LABEL_NAMES = frozenset(label[0] for label in CONTROLLED_LABELS)
+LEGACY_METHOD_LABEL = "engineering-method"
+_METHOD_NAME = re.compile(r"[a-z][a-z0-9-]{0,48}")
+
+
+def method_label(root: Path | None = None) -> str:
+    """Name of the method that bundles this package, read from its method.json.
+
+    Core is copied into each method; the label on managed Issues must name the
+    method that owns the backlog, not the one this package is named after.
+    Without a readable identity (Core's own checkout) the historical name is kept.
+    """
+    root = Path(__file__).resolve().parents[1] if root is None else root
+    try:
+        name = json.loads((root / "method.json").read_text(encoding="utf-8"))["name"]
+    except (OSError, ValueError, KeyError, TypeError):
+        return LEGACY_METHOD_LABEL
+    return name if isinstance(name, str) and _METHOD_NAME.fullmatch(name) else LEGACY_METHOD_LABEL
+
+
+def controlled_labels(label: str) -> tuple[tuple[str, str, str], ...]:
+    display = label.replace("-", " ").title()
+    return (
+        (label, "0B7285", f"Managed by Peter's {display}."),
+        ("priority:p0", "B60205", "Blocking or urgent work."),
+        ("priority:p1", "D93F0B", "Next planned work."),
+        ("priority:p2", "FBCA04", "Planned work."),
+        ("priority:p3", "C5DEF5", "Later improvement."),
+        ("status:open", "1D76DB", f"Open {display} work."),
+        ("status:in-progress", "5319E7", f"{display} work in progress."),
+        ("status:blocked", "B60205", f"{display} work currently blocked."),
+    )
+
+
+METHOD_LABEL = method_label()
+CONTROLLED_LABELS: tuple[tuple[str, str, str], ...] = controlled_labels(METHOD_LABEL)
+# The historical label stays controlled so that an Issue created before the
+# method had its own label loses it on the next synchronization.
+CONTROLLED_LABEL_NAMES = frozenset(label[0] for label in CONTROLLED_LABELS) | {LEGACY_METHOD_LABEL}
 QUEUE_SCHEMA_VERSION = 1
 QUEUE_KINDS = frozenset({"add", "status", "priority", "dependencies"})
 
@@ -147,7 +174,7 @@ def _remote_map(
 
 
 def _labels(item: BacklogItem) -> tuple[str, ...]:
-    labels = ["engineering-method", f"priority:{item.priority.value.lower()}"]
+    labels = [METHOD_LABEL, f"priority:{item.priority.value.lower()}"]
     if item.status is not TaskStatus.COMPLETE:
         labels.append(f"status:{item.status.value.replace('_', '-')}")
     return tuple(labels)
diff --git a/tests/test_issues_regressions.py b/tests/test_issues_regressions.py
index f89f5c1..ee171e6 100644
--- a/tests/test_issues_regressions.py
+++ b/tests/test_issues_regressions.py
@@ -171,7 +171,7 @@ def test_partial_failure_retry_upserts_every_field_and_reconciles_relations(self
             identifier="EM-002",
             title="EM-002: Old blocker",
             state="open",
-            labels=("engineering-method", "priority:p3", "status:open"),
+            labels=(issues.METHOD_LABEL, "priority:p3", "status:open"),
         )
         runner = MutableGitHubRunner(issues=tuple(noise + [parent, blocker]), page_size=100)
         runner.sub_issues[150] = {90_002}
@@ -199,7 +199,7 @@ def test_partial_failure_retry_upserts_every_field_and_reconciles_relations(self
         self.assertEqual(by_id["EM-001"]["state"], "open")
         self.assertEqual(
             {label["name"] for label in by_id["EM-001"]["labels"]},
-            {"custom", "engineering-method", "priority:p1", "status:open"},
+            {"custom", issues.METHOD_LABEL, "priority:p1", "status:open"},
         )
         self.assertIn('Notes JSON: "Keep context"', str(by_id["EM-001"]["body"]))
         self.assertEqual(by_id["EM-002"]["state"], "closed")
@@ -209,7 +209,7 @@ def test_partial_failure_retry_upserts_every_field_and_reconciles_relations(self
         self.assertEqual(
             set(runner.labels),
             {
-                "engineering-method",
+                issues.METHOD_LABEL,
                 "priority:p0",
                 "priority:p1",
                 "priority:p2",
@@ -240,21 +240,21 @@ def test_reparents_only_after_removing_the_stale_parent_relation(self) -> None:
                 101,
                 identifier="EM-001",
                 title="EM-001: Desired parent",
-                labels=("engineering-method", "priority:p1", "status:open"),
+                labels=(issues.METHOD_LABEL, "priority:p1", "status:open"),
             ),
             remote_issue(
                 2,
                 102,
                 identifier="EM-001.1",
                 title="EM-001.1: Child",
-                labels=("engineering-method", "priority:p1", "status:open"),
+                labels=(issues.METHOD_LABEL, "priority:p1", "status:open"),
             ),
             remote_issue(
                 3,
                 103,
                 identifier="EM-002",
                 title="EM-002: Stale parent",
-                labels=("engineering-method", "priority:p1", "status:open"),
+                labels=(issues.METHOD_LABEL, "priority:p1", "status:open"),
             ),
         )
         runner = MutableGitHubRunner(issues=remote)
@@ -328,7 +328,7 @@ def test_refresh_reads_remote_state_instead_of_remigrating_the_cache(self) -> No
                 ),
                 "state": "open",
                 "labels": [
-                    {"name": "engineering-method"},
+                    {"name": issues.METHOD_LABEL},
                     {"name": "priority:p0"},
                     {"name": "status:in-progress"},
                 ],
diff --git a/tests/test_method_identity.py b/tests/test_method_identity.py
index 027c26c..9be5446 100644
--- a/tests/test_method_identity.py
+++ b/tests/test_method_identity.py
@@ -6,9 +6,43 @@
 import subprocess
 import tempfile
 import unittest
+import unittest.mock
 import zipfile
 from scripts.package_plugin import build_package
 ROOT=Path(__file__).resolve().parents[1]
+import engineering_method.issues as issues
+from engineering_method.gh import RemoteIssue
+from engineering_method.models import BacklogItem, Priority, TaskStatus
+
+class MethodLabelTests(unittest.TestCase):
+    """Managed Issues carry the label of the method that owns the backlog."""
+    def identity(self, content):
+        root=Path(tempfile.mkdtemp());self.addCleanup(shutil.rmtree,root)
+        if content is not None:(root/'method.json').write_text(content)
+        return root
+    def test_label_comes_from_the_bundling_method_identity(self):
+        # A hard-coded name labels a Writing Method backlog as engineering-method.
+        self.assertEqual('writing-method',issues.method_label(self.identity(json.dumps({'name':'writing-method'}))))
+        self.assertEqual('engineering-method',issues.method_label(self.identity(json.dumps({'name':'engineering-method'}))))
+    def test_missing_or_unusable_identity_keeps_the_historical_label(self):
+        for content in [None,'not json',json.dumps({}),json.dumps({'name':'Bad Name; rm'}),json.dumps({'name':7})]:
+            self.assertEqual('engineering-method',issues.method_label(self.identity(content)))
+    def test_installed_identity_matches_this_checkout(self):
+        manifest=ROOT/'method.json'
+        expected=json.loads(manifest.read_text())['name'] if manifest.is_file() else 'engineering-method'
+        self.assertEqual(expected,issues.METHOD_LABEL)
+        self.assertEqual(issues.METHOD_LABEL,issues.CONTROLLED_LABELS[0][0])
+    def test_descriptions_name_the_method(self):
+        labels={name:description for name,_,description in issues.controlled_labels('writing-method')}
+        self.assertEqual("Managed by Peter's Writing Method.",labels['writing-method'])
+        self.assertEqual('Open Writing Method work.',labels['status:open'])
+        self.assertNotIn('engineering-method',labels)
+    def test_issue_labelled_under_the_historical_name_is_relabelled(self):
+        item=BacklogItem(id='WM-001',title='Video',status=TaskStatus.IN_PROGRESS,priority=Priority.P1,parent_id=None,depends_on=(),notes='',updated_at='2026-11-13T00:00:00Z')
+        remote=RemoteIssue(id=1,number=1,title='WM-001: Video',body='',state='open',labels=('engineering-method','priority:p1','status:open','custom'),updated_at='2026-11-13T00:00:00Z')
+        with unittest.mock.patch.object(issues,'METHOD_LABEL','writing-method'):
+            desired=issues._desired_remote_labels(item,remote)
+        self.assertEqual(('custom','writing-method','priority:p1','status:in-progress'),desired)
 
 class MethodIdentityTests(unittest.TestCase):
     def test_writing_archive_uses_committed_manifest_identity(self):