agentbundle 0.51.0__tar.gz → 0.52.1__tar.gz

{agentbundle-0.51.0/agentbundle.egg-info → agentbundle-0.52.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentbundle
-Version: 0.51.0
+Version: 0.52.1
 Summary: npm for your coding agent. Install packs of skills, subagents, and hooks into any repo, for every major agent.
 Author-email: eugenelim <eugenelim@users.noreply.github.com>
 License-Expression: Apache-2.0 OR MIT
@@ -35,6 +35,25 @@ python -m pip install agentbundle
 
 Requires Python 3.11+. Runs on macOS, Linux, and Windows.
 
+## What's new in 0.52.1
+
+The workspace-status engine and MCP tool now route `shape` entries to
+`intent`. The shaping suggestion and the `shape` dispatch need
+`product-engineering` 1.0.0 or later.
+
+## What's new in 0.52.0
+
+The workspace-status MCP tool now surfaces a former legacy entry (a bare
+`spec/<slug>` string or other accepted legacy shape) as an `unsupported_legacy`
+finding. The entry is absent from `ready` and `blocked`; ordinary
+reconciliation no longer accepts legacy shapes as lifecycle members. A
+canonical entry with a surviving historical alias appears in `blocked` with a
+`duplicate_membership` finding and does not appear in `ready`. Delete the alias
+and the canonical entry dispatches normally.
+
+The `capture-work` alias for `work-intake` is removed as part of Core 3.0.0.
+All intake requests should go to `work-intake`.
+
 ## What's new in 0.51.0
 
 HTTPS catalogue acquisition now selects credentials automatically. Set

{agentbundle-0.51.0 → agentbundle-0.52.1}/README-pypi.md

@@ -14,6 +14,25 @@ python -m pip install agentbundle
 
 Requires Python 3.11+. Runs on macOS, Linux, and Windows.
 
+## What's new in 0.52.1
+
+The workspace-status engine and MCP tool now route `shape` entries to
+`intent`. The shaping suggestion and the `shape` dispatch need
+`product-engineering` 1.0.0 or later.
+
+## What's new in 0.52.0
+
+The workspace-status MCP tool now surfaces a former legacy entry (a bare
+`spec/<slug>` string or other accepted legacy shape) as an `unsupported_legacy`
+finding. The entry is absent from `ready` and `blocked`; ordinary
+reconciliation no longer accepts legacy shapes as lifecycle members. A
+canonical entry with a surviving historical alias appears in `blocked` with a
+`duplicate_membership` finding and does not appear in `ready`. Delete the alias
+and the canonical entry dispatches normally.
+
+The `capture-work` alias for `work-intake` is removed as part of Core 3.0.0.
+All intake requests should go to `work-intake`.
+
 ## What's new in 0.51.0
 
 HTTPS catalogue acquisition now selects credentials automatically. Set

{agentbundle-0.51.0 → agentbundle-0.52.1}/agentbundle/_data/workspace_status_engine.py

@@ -442,6 +442,10 @@ class Initiative:
     work: InitiativeWork
     shaping: InitiativeShaping
     brief_queue: BriefQueue | None
+    # An open shaping or brief entry that no canonical parse accepted. Ordinary
+    # reconciliation drops it from the typed lists above, so closeout reads this
+    # flag to keep an unsupported entry from passing as an empty initiative.
+    has_unsupported_open_entry: bool = False
 
 
 @dataclasses.dataclass
@@ -1350,6 +1354,7 @@ def _accepted_legacy_entry(collection: str, raw: object) -> LegacyWorkspaceEntry
             )
             if (
                 _is_legacy_slug(raw.get("slug"))
+                and isinstance(entry_type, str)
                 and entry_type in _SHAPING_TYPES
                 and needs_are_supported
             ):
@@ -1381,6 +1386,7 @@ def _accepted_legacy_entry(collection: str, raw: object) -> LegacyWorkspaceEntry
         summary_is_supported = "summary" not in raw or isinstance(raw["summary"], str)
         if (
             _is_legacy_slug(raw.get("slug"))
+            and isinstance(raw.get("type"), str)
             and raw.get("type") in _SHAPING_TYPES
             and needs_are_supported
             and source_is_supported
@@ -2546,13 +2552,12 @@ def _parse_membership_entry(
     status: str,
 ) -> tuple[
     WorkspaceMembership | None,
-    LegacyWorkspaceMembership | None,
     list[RoutingFinding],
     str | None,
 ]:
     parsed, findings = parse_workspace_entry(raw)
     if parsed is not None:
-        return WorkspaceMembership(parsed, ini_slug, collection, status), None, [], None
+        return WorkspaceMembership(parsed, ini_slug, collection, status), [], None
     raw_path = raw.get("path") if isinstance(raw, dict) else None
     if _is_repository_relative_path(raw_path):
         findings = [
@@ -2560,23 +2565,19 @@ def _parse_membership_entry(
             if not finding.path else finding
             for finding in findings
         ]
-    legacy = parse_legacy_workspace_entry(collection, raw)
-    if legacy.finding.code == "legacy_entry":
-        return None, LegacyWorkspaceMembership(legacy, ini_slug, collection, status), [
-            legacy.finding
-        ], None
+    legacy = _legacy_path_finding(collection, raw)
     if legacy.finding.code == "invalid_artifact_path" and not _is_target_like_entry(raw):
-        return None, None, [legacy.finding], None
+        return None, [legacy.finding], None
     if legacy.finding.code == "unsupported_legacy" and not _is_target_like_entry(raw):
-        return None, None, [legacy.finding], None
+        return None, [legacy.finding], None
     if findings:
         blocks_dependencies = any(
             finding.code in {"invalid_entry", "invalid_artifact_path"}
             for finding in findings
         )
         blocked_path = _target_like_blocked_path(raw) if blocks_dependencies else None
-        return None, None, findings, blocked_path
-    return None, None, [legacy.finding], None
+        return None, findings, blocked_path
+    return None, [legacy.finding], None
 
 
 def _extract_canonical_memberships(
@@ -2588,7 +2589,6 @@ def _extract_canonical_memberships(
     list[ParseBlockedWorkspaceMembership],
 ]:
     memberships: list[WorkspaceMembership] = []
-    legacy_memberships: list[LegacyWorkspaceMembership] = []
     findings: list[RoutingFinding] = []
     parse_blocked_memberships: list[ParseBlockedWorkspaceMembership] = []
     for section_name, top_level_names in _TOP_LEVEL_ENTRY_COLLECTIONS.items():
@@ -2605,7 +2605,6 @@ def _extract_canonical_memberships(
             for entry_index, raw_entry in enumerate(entries):
                 (
                     membership,
-                    legacy_membership,
                     entry_findings,
                     blocked_path,
                 ) = _parse_membership_entry(raw_entry, collection, "", "")
@@ -2613,10 +2612,6 @@ def _extract_canonical_memberships(
                     memberships.append(
                         dataclasses.replace(membership, entry_index=entry_index)
                     )
-                if legacy_membership is not None:
-                    legacy_memberships.append(
-                        dataclasses.replace(legacy_membership, entry_index=entry_index)
-                    )
                 if blocked_path is not None:
                     parse_blocked_memberships.append(
                         ParseBlockedWorkspaceMembership(
@@ -2665,7 +2660,6 @@ def _extract_canonical_memberships(
                 for entry_index, raw_entry in enumerate(entries):
                     (
                         membership,
-                        legacy_membership,
                         entry_findings,
                         blocked_path,
                     ) = _parse_membership_entry(raw_entry, collection, ini_slug, status)
@@ -2673,10 +2667,6 @@ def _extract_canonical_memberships(
                         memberships.append(
                             dataclasses.replace(membership, entry_index=entry_index)
                         )
-                    if legacy_membership is not None:
-                        legacy_memberships.append(
-                            dataclasses.replace(legacy_membership, entry_index=entry_index)
-                        )
                     if blocked_path is not None:
                         parse_blocked_memberships.append(
                             ParseBlockedWorkspaceMembership(
@@ -2687,7 +2677,73 @@ def _extract_canonical_memberships(
                             )
                         )
                     findings.extend(entry_findings)
-    return memberships, legacy_memberships, findings, parse_blocked_memberships
+    return memberships, [], findings, parse_blocked_memberships
+
+
+def extract_legacy_migration_memberships(workspace: dict) -> list[LegacyWorkspaceMembership]:
+    """Return accepted legacy memberships for explicit migration operations only."""
+
+    memberships: list[LegacyWorkspaceMembership] = []
+    for section_name, top_level_names in _TOP_LEVEL_ENTRY_COLLECTIONS.items():
+        section = workspace.get(section_name, {})
+        if not isinstance(section, dict):
+            continue
+        for list_name in top_level_names:
+            entries = section.get(list_name, [])
+            if not isinstance(entries, list):
+                continue
+            collection = _collection_label(section_name, list_name)
+            for entry_index, raw_entry in enumerate(entries):
+                legacy = parse_legacy_workspace_entry(collection, raw_entry)
+                if legacy.finding.code == "legacy_entry":
+                    memberships.append(
+                        LegacyWorkspaceMembership(
+                            legacy,
+                            "",
+                            collection,
+                            "",
+                            entry_index=entry_index,
+                        )
+                    )
+    for raw_ini_slug, section in workspace.items():
+        if not isinstance(raw_ini_slug, str) or not _CANONICAL_INITIATIVE_RE.fullmatch(
+            raw_ini_slug
+        ):
+            continue
+        if not isinstance(section, dict):
+            continue
+        status = section.get("status", "")
+        status = status if isinstance(status, str) else ""
+        for section_name, initiative_names in _INITIATIVE_ENTRY_COLLECTIONS.items():
+            subsection = section.get(section_name, {})
+            if not isinstance(subsection, dict):
+                continue
+            for list_name in initiative_names:
+                entries = subsection.get(list_name, [])
+                if entries is None:
+                    entries = []
+                if (
+                    section_name == "brief_queue"
+                    and list_name == "executing"
+                    and isinstance(entries, str)
+                ):
+                    entries = [] if entries == "" else [entries]
+                if not isinstance(entries, list):
+                    continue
+                collection = _collection_label(section_name, list_name)
+                for entry_index, raw_entry in enumerate(entries):
+                    legacy = parse_legacy_workspace_entry(collection, raw_entry)
+                    if legacy.finding.code == "legacy_entry":
+                        memberships.append(
+                            LegacyWorkspaceMembership(
+                                legacy,
+                                raw_ini_slug,
+                                collection,
+                                status,
+                                entry_index=entry_index,
+                            )
+                        )
+    return memberships
 
 
 def _membership_status(membership: WorkspaceMembership) -> str | None:
@@ -2993,12 +3049,9 @@ def resolve_selected_memberships(
     workspace: dict, selected_artifact_paths: list[str]
 ) -> dict[str, list[dict]]:
     """Resolve selected occurrences from already-parsed workspace state."""
-    (
-        memberships,
-        legacy_memberships,
-        findings,
-        parse_blocked_memberships,
-    ) = _extract_canonical_memberships(workspace)
+    memberships, _legacy_memberships, findings, parse_blocked_memberships = (
+        _extract_canonical_memberships(workspace)
+    )
     if any(finding.code == "invalid_workspace" for finding in findings):
         raise ValueError("invalid workspace")
 
@@ -3022,22 +3075,6 @@ def resolve_selected_memberships(
                 "form": "canonical",
             }
         )
-    for legacy_membership in legacy_memberships:
-        path = _legacy_canonical_alias(legacy_membership.entry)
-        if (
-            legacy_membership.collection not in _SELECTED_SPEC_COLLECTIONS
-            or path not in occurrences_by_path
-        ):
-            continue
-        occurrences_by_path[path].append(
-            {
-                "canonical_artifact_path": path,
-                "initiative": legacy_membership.ini_slug or None,
-                "collection": legacy_membership.collection,
-                "entry_index": legacy_membership.entry_index,
-                "form": "legacy",
-            }
-        )
     for blocked_membership in parse_blocked_memberships:
         path = blocked_membership.canonical_artifact_path
         if (
@@ -3086,8 +3123,6 @@ def selected_membership_status(root: Path, selectors: list[str]) -> dict[str, ob
     except OSError:
         return {"error": {"code": "invalid_workspace"}}
     try:
-        # The pure seam calls _extract_canonical_memberships(...) and
-        # _legacy_canonical_alias(...) for selected identity resolution.
         occurrences_by_path = resolve_selected_memberships(
             workspace, selected_artifact_paths
         )
@@ -3107,26 +3142,6 @@ def selected_membership_status(root: Path, selectors: list[str]) -> dict[str, ob
     }
 
 
-def _legacy_membership_is_cooled(
-    membership: LegacyWorkspaceMembership,
-    root: Path | None,
-    cooled: frozenset[Path],
-) -> bool:
-    """True when a legacy membership's canonical artifact is cooled.
-
-    A legacy entry stores `spec/alpha`, so the canonical alias has to be
-    recovered before the membership key applies. Resolving the stored form
-    directly yields `<root>/spec/alpha`, which cannot equal any cooled path
-    whatever the lifecycle record says, so the check silently never fires.
-    """
-    if root is None or not cooled:
-        return False
-    alias = _legacy_canonical_alias(membership.entry)
-    if alias is None:
-        return False
-    return _confined_artifact_path(root, alias) in cooled
-
-
 def _membership_is_cooled(
     membership: WorkspaceMembership,
     root: Path | None,
@@ -3148,7 +3163,6 @@ def _brief_child_spec_states(
     workspace: dict,
     root: Path | None,
     cooled: frozenset[Path],
-    legacy_memberships: list[LegacyWorkspaceMembership],
 ) -> tuple[dict[str, set[str]], frozenset[str], frozenset[str]]:
     """Map each brief to its children's observed states; flag unevaluable scope.
 
@@ -3196,21 +3210,10 @@ def _brief_child_spec_states(
     # with no repair available — declaring a resolving path was already done,
     # and declaring empty would be false.
     #
-    # Legacy memberships are included because a bare-string brief queue entry
-    # carries `kind = "brief"` and a real path, and a child declaring it has
-    # declared the truth. Reading them here decides attribution only; it
-    # dispatches nothing, which is the line the routing contract draws.
-    # Two comprehensions rather than one over an unpacked pair: the canonical
-    # and legacy membership types differ, so unpacking them together widens the
-    # element type to `object` and the attribute access stops type-checking.
     brief_membership_paths = {
         membership.entry.path
         for membership in memberships
         if membership.entry.kind == "brief" and membership.entry.path is not None
-    } | {
-        legacy.entry.path
-        for legacy in legacy_memberships
-        if legacy.entry.kind == "brief" and legacy.entry.path is not None
     }
     for membership in memberships:
         entry = membership.entry
@@ -3656,7 +3659,7 @@ def cooled_work_entry_paths(
     initiative parse builds `queue` and `active` by list comprehension over those
     same arrays. So index `i` names the same element on both sides.
     """
-    memberships, legacy_memberships, _findings, _blocked = (
+    memberships, _legacy_memberships, _findings, _blocked = (
         _extract_canonical_memberships(workspace)
     )
     by_initiative: dict[str, set[tuple[str, int]]] = {}
@@ -3667,13 +3670,6 @@ def cooled_work_entry_paths(
             by_initiative.setdefault(membership.ini_slug, set()).add(
                 (membership.collection, membership.entry_index)
             )
-    for legacy in legacy_memberships:
-        if not legacy.collection.startswith("work."):
-            continue
-        if _legacy_membership_is_cooled(legacy, root, cooled):
-            by_initiative.setdefault(legacy.ini_slug, set()).add(
-                (legacy.collection, legacy.entry_index)
-            )
     return by_initiative
 
 
@@ -3694,13 +3690,12 @@ def run_canonical_reconciliation(
         path = blocked.canonical_artifact_path
         parse_blocked_path_counts[path] = parse_blocked_path_counts.get(path, 0) + 1
     # Cooling is applied at evaluation and emission, never here. Every fact
-    # derived below — by_path, duplicate_paths, cycle_paths, legacy_alias_counts
-    # and the structural loop — must see a cooled artifact as *cooled*, not as
-    # *absent*, or a lifecycle record silently erases unrelated conclusions
-    # about it. What the cooled set governs is the artifact *body*: for a cooled
-    # membership the structural loop and _brief_child_spec_states skip the
-    # predicates that would have to open it, keeping the ones derived from the
-    # workspace entry alone.
+    # derived below — by_path, duplicate_paths, cycle_paths, and the structural
+    # loop — must see a cooled artifact as *cooled*, not as *absent*, or a
+    # lifecycle record silently erases unrelated conclusions about it. What the
+    # cooled set governs is the artifact *body*: for a cooled membership the
+    # structural loop and _brief_child_spec_states skip the predicates that would
+    # have to open it, keeping the ones derived from the workspace entry alone.
     parse_blocked_paths = set(parse_blocked_path_counts)
     local_memberships = [
         membership for membership in memberships if membership.entry.path is not None
@@ -3709,44 +3704,35 @@ def run_canonical_reconciliation(
     for membership in local_memberships:
         assert membership.entry.path is not None
         by_path.setdefault(membership.entry.path, []).append(membership)
-    legacy_alias_counts: dict[str, int] = {}
-    for legacy_membership in legacy_memberships:
-        alias = _legacy_canonical_alias(legacy_membership.entry)
-        if alias is not None:
-            legacy_alias_counts[alias] = legacy_alias_counts.get(alias, 0) + 1
     duplicate_paths = {
         path
         for path, items in by_path.items()
-        if len(items) + legacy_alias_counts.get(path, 0) > 1
+        if len(items) > 1
     }
-    mixed_parse_legacy_duplicate_paths = {
-        path
-        for path in parse_blocked_paths
-        if path not in by_path and legacy_alias_counts.get(path, 0) > 0
+    # Alias-refused paths: canonical reconciliation may decode a historical alias
+    # only to refuse. A canonical entry stays non-dispatchable while any historical
+    # entry that the retained decoder maps to the same artifact path survives
+    # anywhere in the workspace. One extraction per reconciliation run.
+    _alias_refused_paths = {
+        _alias_path
+        for _m in extract_legacy_migration_memberships(workspace)
+        if (_alias_path := _legacy_canonical_alias(_m.entry)) is not None
+        and _alias_path in by_path
     }
+    duplicate_paths.update(_alias_refused_paths)
     parse_only_duplicate_paths = {
         path
         for path, count in parse_blocked_path_counts.items()
         if count > 1 and path not in by_path
     }
-    legacy_only_duplicate_paths = {
-        path
-        for path, count in legacy_alias_counts.items()
-        if count > 1 and path not in by_path
-    }
-    legacy_only_duplicate_findings = [
+    parse_only_duplicate_findings = [
         _finding("duplicate_membership", path, "duplicate lifecycle entry")
-        for path in sorted(
-            legacy_only_duplicate_paths
-            | mixed_parse_legacy_duplicate_paths
-            | parse_only_duplicate_paths
-        )
+        for path in sorted(parse_only_duplicate_paths)
     ]
     cycle_paths = _dependency_cycles(local_memberships)
     brief_child_states, briefs_with_cooled_children, cooled_scope_unknown = (
         _brief_child_spec_states(
             local_memberships, workspace, root, cooled,
-            legacy_memberships=legacy_memberships,
         )
     )
     # Emitted here rather than in `_structural_findings`, whose findings add
@@ -3762,8 +3748,6 @@ def run_canonical_reconciliation(
     )
     duplicate_paths.update(path for path in parse_blocked_paths if path in by_path)
     structurally_blocked_paths: set[str] = {
-        *legacy_only_duplicate_paths,
-        *mixed_parse_legacy_duplicate_paths,
         *parse_only_duplicate_paths,
         *parse_blocked_paths,
     }
@@ -3827,7 +3811,7 @@ def run_canonical_reconciliation(
     }
     findings = [
         *parse_findings,
-        *legacy_only_duplicate_findings,
+        *parse_only_duplicate_findings,
         *cooled_membership_findings,
         *cooled_scope_findings,
         *(finding for evaluation in evaluations for finding in evaluation.findings),
@@ -3835,20 +3819,34 @@ def run_canonical_reconciliation(
     return CanonicalWorkspaceResult(
         cooled=cooled,
         memberships=memberships,
-        # Emission, not derivation: `legacy_alias_counts` above still counts a
-        # cooled legacy entry, so cooling one half of a duplicate pair does not
-        # erase the duplicate finding for the half that stays visible.
-        legacy_memberships=[
-            membership
-            for membership in legacy_memberships
-            if not _legacy_membership_is_cooled(membership, root, cooled)
-        ],
+        legacy_memberships=[],
         findings=findings,
         evaluations=evaluations,
         dispatch_by_path=dispatch_by_path,
     )
 
 
+def _has_unsupported_open_entry(shaping_raw: object, brief_raw: object) -> bool:
+    """True when an open shaping or brief collection holds a non-canonical entry."""
+
+    def raw_entries(section: object, name: str) -> list[object]:
+        if not isinstance(section, dict):
+            return []
+        entries = section.get(name, [])
+        if isinstance(entries, list):
+            return entries
+        return [] if entries in ("", None) else [entries]
+
+    open_entries = [
+        *raw_entries(shaping_raw, "active"),
+        *raw_entries(shaping_raw, "backlog"),
+        *raw_entries(brief_raw, "executing"),
+        *raw_entries(brief_raw, "ready"),
+        *raw_entries(brief_raw, "draft"),
+    ]
+    return any(parse_workspace_entry(raw)[0] is None for raw in open_entries)
+
+
 def _supported_brief_queue_path(raw: object) -> str | None:
     """Return a canonical target or released scalar brief-queue path."""
     if isinstance(raw, str):
@@ -3963,6 +3961,9 @@ def extract_initiatives(workspace: dict) -> list[Initiative]:
             work=work,
             shaping=shaping,
             brief_queue=brief_queue,
+            has_unsupported_open_entry=_has_unsupported_open_entry(
+                shaping_raw, brief_raw
+            ),
         ))
     return initiatives
 
@@ -4882,7 +4883,7 @@ def extract_top_level_backlog(workspace: dict) -> list[ShapingEntry]:
 
 
 _SHAPING_TYPE_TO_SKILL: dict[str, str] = {
-    "shape":    "frame-intent",
+    "shape":    "intent",
     "research": "desk-research-project-start",
     "strategy": "frame-situation",
     "design":   "experience-status",
@@ -4909,10 +4910,10 @@ def check_shaping_guard(
             continue
         for entry in ini.shaping.active + ini.shaping.backlog:
             if entry.slug == spec_slug:
-                return _SHAPING_TYPE_TO_SKILL.get(entry.entry_type, "frame-intent")
+                return _SHAPING_TYPE_TO_SKILL.get(entry.entry_type, "intent")
     for entry in (top_level_backlog or []):
         if entry.slug == spec_slug:
-            return _SHAPING_TYPE_TO_SKILL.get(entry.entry_type, "frame-intent")
+            return _SHAPING_TYPE_TO_SKILL.get(entry.entry_type, "intent")
     return None
 
 
@@ -5084,6 +5085,14 @@ def _repair_entry_eligibility(
         }
         if blocking_codes - {"impossible_transition", "unapproved_spec"}:
             return False, "type2-queue-canonical-blocked"
+        # Defence in depth: canonical reconciliation already refuses dispatch
+        # while a historical alias survives, but the repair seam also checks so
+        # moving the entry does not leave the spec in two lifecycle collections.
+        if any(
+            _legacy_canonical_alias(membership.entry) == spec_path
+            for membership in extract_legacy_migration_memberships(workspace)
+        ):
+            return False, "type2-queue-canonical-blocked"
         return True, None
     return False, "type2-queue-canonical-blocked"
 
@@ -5781,9 +5790,10 @@ def compute_migration_plan(
             )
         )
     canonical = run_canonical_reconciliation(workspace, root)
+    migration_memberships = extract_legacy_migration_memberships(workspace)
     matches = [
         membership
-        for membership in canonical.legacy_memberships
+        for membership in migration_memberships
         if membership.ini_slug == selection.source_membership["ini_slug"]
         and membership.collection == selection.source_membership["collection"]
         and membership.entry_index == selection.source_membership["entry_index"]

{agentbundle-0.51.0 → agentbundle-0.52.1}/agentbundle/_data/workspace_status_prune.py

@@ -46,10 +46,21 @@ _legacy_canonical_alias = _engine._legacy_canonical_alias
 _migration_file_bytes = _engine._migration_file_bytes
 _parse_membership_entry = _engine._parse_membership_entry
 confine_migration_path = _engine.confine_migration_path
+parse_legacy_workspace_entry = _engine.parse_legacy_workspace_entry
 parse_workspace = _engine.parse_workspace
 resolve_selected_memberships = _engine.resolve_selected_memberships
 
 
+def _repair_legacy_entry(collection: str, raw: object):
+    """Decode a historical legacy entry for prune closure, or return None.
+
+    Ordinary reconciliation rejects these shapes. Prune is a repair operation,
+    so a surviving legacy alias must still deny closure of the artifact it names.
+    """
+    legacy = parse_legacy_workspace_entry(collection, raw)
+    return legacy if legacy.finding.code == "legacy_entry" else None
+
+
 def _resolve_prune_closure_memberships(
     workspace: dict, selected_artifact_paths: list[str]
 ) -> dict[str, list[dict]]:
@@ -77,12 +88,17 @@ def _resolve_prune_closure_memberships(
             collection = ".".join(collection_parts)
             status = value.get("status", "") if initiative is not None else ""
             status = status if isinstance(status, str) else ""
-            membership, legacy, _, blocked_path = _parse_membership_entry(
+            membership, _, blocked_path = _parse_membership_entry(
                 value,
                 collection,
                 initiative or "",
                 status,
             )
+            legacy = (
+                _repair_legacy_entry(collection, value) if membership is None else None
+            )
+            if legacy is not None:
+                blocked_path = None
             path: str | None = None
             form = ""
             if (
@@ -92,7 +108,7 @@ def _resolve_prune_closure_memberships(
                 path = membership.entry.path
                 form = "canonical"
             elif legacy is not None:
-                legacy_path = _legacy_canonical_alias(legacy.entry)
+                legacy_path = _legacy_canonical_alias(legacy)
                 if legacy_path in occurrences_by_path:
                     path = legacy_path
                     form = "legacy"
@@ -140,21 +156,9 @@ def _resolve_prune_closure_memberships(
                         else string_parts
                     )
                     collection = ".".join(collection_parts)
-                    status = ""
-                    if initiative is not None:
-                        section = workspace.get(initiative)
-                        if isinstance(section, dict) and isinstance(
-                            section.get("status"), str
-                        ):
-                            status = section["status"]
-                    _, legacy, _, _ = _parse_membership_entry(
-                        child,
-                        collection,
-                        initiative or "",
-                        status,
-                    )
+                    legacy = _repair_legacy_entry(collection, child)
                     if legacy is not None:
-                        path = _legacy_canonical_alias(legacy.entry)
+                        path = _legacy_canonical_alias(legacy)
                         if path in occurrences_by_path:
                             occurrence = {
                                 "canonical_artifact_path": path,

{agentbundle-0.51.0 → agentbundle-0.52.1}/agentbundle/version.py

@@ -14,7 +14,7 @@ import tomllib
 from importlib.resources import files
 from pathlib import Path
 
-CLI_VERSION = "0.51.0"
+CLI_VERSION = "0.52.1"
 
 _HERE = Path(__file__).resolve().parent
 

{agentbundle-0.51.0 → agentbundle-0.52.1}/agentbundle/workspace_mcp.py

@@ -86,7 +86,7 @@ _LIFECYCLE_MANIFEST: dict[str, dict] = {
         "required_pack": "desk-research",
     },
     "shape": {
-        "dispatch_skill": "frame-intent",
+        "dispatch_skill": "intent",
         "output_pattern": [
             "docs/product/intents/{slug}.md",
             "docs/product/shaping/{slug}/**",