@mc-and-his-agents/loom-installer 0.1.113 → 0.1.115

package/payload/skills/loom-resume/.loom-runtime/shared/scripts/loom_check.py

@@ -4336,6 +4336,17 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
             if pr_template:
                 (target / ".github" / "PULL_REQUEST_TEMPLATE.md").write_text("## Summary\n", encoding="utf-8")
 
+        def write_small_existing_repo(target: Path, *, pr_template: bool = False) -> None:
+            (target / ".github" / "workflows").mkdir(parents=True, exist_ok=True)
+            (target / "src").mkdir(parents=True, exist_ok=True)
+            (target / "README.md").write_text("# Small Existing Repo\n", encoding="utf-8")
+            (target / "AGENTS.md").write_text("# Root Rules\n", encoding="utf-8")
+            (target / "src" / "main.py").write_text("print('ok')\n", encoding="utf-8")
+            (target / ".github" / "workflows" / "ci.yml").write_text("name: ci\n", encoding="utf-8")
+            (target / "Makefile").write_text("check:\n\t@echo ok\n", encoding="utf-8")
+            if pr_template:
+                (target / ".github" / "PULL_REQUEST_TEMPLATE.md").write_text("## Summary\n", encoding="utf-8")
+
         attach_only_forbidden_patterns = (
             ".loom/work-items/**",
             ".loom/progress/**",
@@ -4343,6 +4354,15 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
             ".loom/reviews/**",
             ".loom/specs/**",
         )
+        default_release_paths = (
+            ".loom/companion/releases/changelog.md",
+            ".loom/companion/releases/release-notes.md",
+            ".loom/companion/releases/migration-notes.md",
+            ".loom/companion/releases/rollback.md",
+            ".loom/companion/releases/catalog.json",
+            ".loom/companion/releases/current.json",
+            ".loom/companion/releases/status.json",
+        )
 
         def matches_forbidden(path: str, pattern: str) -> bool:
             if pattern.endswith("/**"):
@@ -4358,6 +4378,50 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
                     return pattern
             return None
 
+        def assert_no_default_release_target(target: Path, payload: dict[str, object], context: str) -> None:
+            planned = payload.get("planned_writes")
+            planned_paths = {item.get("path") for item in planned if isinstance(item, dict)} if isinstance(planned, list) else set()
+            initial = payload.get("initial_artifacts")
+            initial_paths = {item.get("path") for item in initial if isinstance(item, dict)} if isinstance(initial, list) else set()
+            absent = payload.get("intentionally_absent")
+            absent_paths = {item.get("path") for item in absent if isinstance(item, dict)} if isinstance(absent, list) else set()
+            serialized = json.dumps(payload, ensure_ascii=False)
+            for release_path in default_release_paths:
+                if release_path in planned_paths:
+                    failures.append(Failure("deep-existing-bootstrap", f"`{context}` must not plan default release target `{release_path}`"))
+                if release_path in initial_paths:
+                    failures.append(Failure("deep-existing-bootstrap", f"`{context}` must not declare default release target `{release_path}`"))
+                if (target / release_path).exists():
+                    failures.append(Failure("deep-existing-bootstrap", f"`{context}` must not generate default release target `{release_path}`"))
+            if ".loom/companion/releases/**" not in absent_paths:
+                failures.append(Failure("deep-existing-bootstrap", f"`{context}` must mark release targets intentionally absent by default"))
+            if "bootstrap-v0.1.0" in serialized:
+                failures.append(Failure("deep-existing-bootstrap", f"`{context}` must not mention placeholder release id `bootstrap-v0.1.0`"))
+            repo_interface_path = target / ".loom/companion/repo-interface.json"
+            if repo_interface_path.exists():
+                repo_interface = json.loads(repo_interface_path.read_text(encoding="utf-8"))
+                if "release_targets" in repo_interface:
+                    failures.append(Failure("deep-existing-bootstrap", f"`{context}` repo-interface must not declare release_targets without release target intent"))
+            surface = build_governance_surface(target)
+            repo_interface_surface = surface.get("repo_interface") if isinstance(surface, dict) else None
+            release_targets = repo_interface_surface.get("release_targets") if isinstance(repo_interface_surface, dict) else None
+            require_release_targets_surface_payload(
+                failures,
+                category="deep-existing-bootstrap",
+                context=f"`{context}` absent release targets",
+                payload=release_targets,
+            )
+            target_release = release_targets.get("target_release") if isinstance(release_targets, dict) else None
+            if not isinstance(release_targets, dict) or release_targets.get("availability") != "absent":
+                failures.append(Failure("deep-existing-bootstrap", f"`{context}` must report release_targets availability absent by default"))
+            if not isinstance(target_release, dict) or target_release.get("result") != "not_applicable":
+                failures.append(Failure("deep-existing-bootstrap", f"`{context}` must report target_release not_applicable when release targets are absent"))
+            if isinstance(release_targets, dict):
+                for surface_key in ("catalog", "current_target", "status"):
+                    surface_entry = release_targets.get(surface_key)
+                    if isinstance(surface_entry, dict) and surface_entry.get("status") == "present":
+                        failures.append(Failure("deep-existing-bootstrap", f"`{context}` must not report absent release target `{surface_key}` as present"))
+
         deep_target = tmp_root / "deep-existing"
         write_repo(deep_target, validation_entry=True, pr_template=True, workflow_doc=True)
         deep_dry_payload, deep_dry_error = load_command_json(
@@ -4404,6 +4468,7 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
                 failures.append(Failure("deep-existing-bootstrap", "`deep-existing dry-run` must report detected repository mode"))
             if not isinstance(write, dict) or write.get("enabled") is not False:
                 failures.append(Failure("deep-existing-bootstrap", "`deep-existing dry-run` must keep write.enabled = false"))
+            assert_no_default_release_target(deep_target, deep_dry_payload, "deep-existing dry-run")
 
         deep_payload, deep_error = load_command_json(
             root,
@@ -4463,6 +4528,7 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
                 host_truth = repo_interface.get("host_truth_locators")
                 if not isinstance(host_truth, dict) or set(host_truth.keys()) != {"work_item", "project_status", "review", "closeout"}:
                     failures.append(Failure("deep-existing-bootstrap", "`deep-existing bootstrap` repo-interface must declare attach-only host truth locators"))
+            assert_no_default_release_target(deep_target, deep_payload, "deep-existing bootstrap")
 
         poisoned_files_target = tmp_root / "deep-existing-poison-files"
         if deep_target.exists() and (deep_target / ".loom/bin/loom_init.py").exists():
@@ -4583,6 +4649,10 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
             intent = explicit_payload.get("adoption_intent")
             recommended = explicit_payload.get("recommended_adoption")
             profile = explicit_payload.get("scaffold_profile")
+            planned = explicit_payload.get("planned_writes")
+            planned_paths = {item.get("path") for item in planned if isinstance(item, dict)} if isinstance(planned, list) else set()
+            initial = explicit_payload.get("initial_artifacts")
+            initial_paths = {item.get("path") for item in initial if isinstance(item, dict)} if isinstance(initial, list) else set()
             if not isinstance(intent, dict) or intent.get("effective") != "execution-control":
                 failures.append(Failure("deep-existing-bootstrap", "explicit full-bootstrap sample must report `adoption_intent.effective = execution-control`"))
             if not isinstance(recommended, dict) or recommended.get("path") != "full-bootstrap":
@@ -4595,12 +4665,17 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
                 ".loom/status/current.md",
                 ".loom/reviews/INIT-0001.json",
                 ".loom/specs/INIT-0001/spec.md",
+                ".loom/specs/INIT-0001/plan.md",
+                ".loom/specs/INIT-0001/implementation-contract.md",
             ):
                 if not (explicit_full_target / required).exists():
                     failures.append(Failure("deep-existing-bootstrap", f"`explicit execution-control bootstrap sample` must generate `{required}`"))
+                if required not in planned_paths or required not in initial_paths:
+                    failures.append(Failure("deep-existing-bootstrap", f"`explicit execution-control bootstrap sample` must declare `{required}` in planned_writes and initial_artifacts"))
+            assert_no_default_release_target(explicit_full_target, explicit_payload, "explicit execution-control bootstrap sample")
 
         light_target = tmp_root / "light-governance"
-        write_repo(light_target, validation_entry=True, pr_template=False, workflow_doc=False)
+        write_small_existing_repo(light_target)
         light_payload, light_error = load_command_json(
             root,
             [
@@ -4620,23 +4695,76 @@ def check_deep_existing_repo_bootstrap(root: Path) -> list[Failure]:
         if light_error:
             failures.append(Failure("deep-existing-bootstrap", f"`light-governance bootstrap sample` failed: {light_error}"))
         else:
+            run = light_payload.get("run")
+            recommended = light_payload.get("recommended_adoption")
             profile = light_payload.get("scaffold_profile")
+            intentionally_absent = light_payload.get("intentionally_absent")
+            absent_paths = (
+                {item.get("path") for item in intentionally_absent if isinstance(item, dict)}
+                if isinstance(intentionally_absent, list)
+                else set()
+            )
+            if not isinstance(run, dict) or run.get("scenario_key") != "small-existing" or run.get("recovery_mode") != "checkpoint-lite":
+                failures.append(Failure("deep-existing-bootstrap", "light-governance sample must model small-existing checkpoint-lite adoption"))
+            if not isinstance(recommended, dict) or recommended.get("path") != "lightweight-retrofit":
+                failures.append(Failure("deep-existing-bootstrap", "light-governance sample must select `recommended_adoption.path = lightweight-retrofit`"))
             if not isinstance(profile, dict) or profile.get("name") != "light-governance":
                 failures.append(Failure("deep-existing-bootstrap", "light-governance sample must report `scaffold_profile.name = light-governance`"))
+            if not isinstance(profile, dict) or profile.get("writes_work_item_carriers") is not False:
+                failures.append(Failure("deep-existing-bootstrap", "light-governance sample must report `writes_work_item_carriers = false`"))
             if not isinstance(light_payload.get("upgrade_triggers"), list) or not light_payload["upgrade_triggers"]:
                 failures.append(Failure("deep-existing-bootstrap", "light-governance sample must report top-level upgrade_triggers"))
+            deferred_text = json.dumps(light_payload.get("deferred_capabilities", []), ensure_ascii=False)
+            if "spec" not in deferred_text or "execution-control" not in deferred_text:
+                failures.append(Failure("deep-existing-bootstrap", "light-governance sample must defer Loom-owned spec carriers to execution-control"))
             planned = light_payload.get("planned_writes")
             planned_paths = {item.get("path") for item in planned if isinstance(item, dict)} if isinstance(planned, list) else set()
-            for required in (".loom/reviews/INIT-0001.json", ".loom/specs/INIT-0001/spec.md", ".github/PULL_REQUEST_TEMPLATE.md"):
+            for required in (".loom/reviews/INIT-0001.json", ".loom/reviews/INIT-0001.spec.json", ".github/PULL_REQUEST_TEMPLATE.md"):
                 if required not in planned_paths or not (light_target / required).exists():
                     failures.append(Failure("deep-existing-bootstrap", f"`light-governance bootstrap sample` must generate `{required}`"))
+            for absent in (".loom/work-items/**", ".loom/progress/**", ".loom/status/current.md", ".loom/specs/**"):
+                if absent not in absent_paths:
+                    failures.append(Failure("deep-existing-bootstrap", f"`light-governance bootstrap sample` must mark `{absent}` intentionally absent"))
             for forbidden in (
                 ".loom/work-items/INIT-0001.md",
                 ".loom/progress/INIT-0001.md",
                 ".loom/status/current.md",
+                ".loom/specs/INIT-0001/spec.md",
+                ".loom/specs/INIT-0001/plan.md",
+                ".loom/specs/INIT-0001/implementation-contract.md",
             ):
                 if forbidden in planned_paths or (light_target / forbidden).exists():
                     failures.append(Failure("deep-existing-bootstrap", f"`light-governance bootstrap sample` must not generate `{forbidden}`"))
+            assert_no_default_release_target(light_target, light_payload, "light-governance bootstrap sample")
+            readme_text = (light_target / ".loom/README.md").read_text(encoding="utf-8") if (light_target / ".loom/README.md").exists() else ""
+            if ".loom/specs" in readme_text or "Spec suite" in readme_text:
+                failures.append(Failure("deep-existing-bootstrap", "`light-governance bootstrap sample` must not declare a spec suite in `.loom/README.md`"))
+            spec_review_text = (light_target / ".loom/reviews/INIT-0001.spec.json").read_text(encoding="utf-8") if (light_target / ".loom/reviews/INIT-0001.spec.json").exists() else ""
+            if "formal spec path" in spec_review_text:
+                failures.append(Failure("deep-existing-bootstrap", "`light-governance spec review placeholder` must not tell operators to consume a formal spec path"))
+            if (light_target / ".loom/bin/loom_init.py").exists():
+                poisoned_light_target = tmp_root / "light-governance-poison-specs"
+                shutil.copytree(light_target, poisoned_light_target)
+                (poisoned_light_target / ".loom/specs/INIT-0001").mkdir(parents=True, exist_ok=True)
+                (poisoned_light_target / ".loom/specs/INIT-0001/spec.md").write_text("# Unexpected Spec\n", encoding="utf-8")
+                poisoned_payload, poisoned_error = load_command_json(
+                    root,
+                    [
+                        "python3",
+                        str(poisoned_light_target / ".loom/bin/loom_init.py"),
+                        "verify",
+                        "--target",
+                        str(poisoned_light_target),
+                    ],
+                )
+                if poisoned_error:
+                    failures.append(Failure("deep-existing-bootstrap", f"`light-governance forbidden spec verify` failed: {poisoned_error}"))
+                else:
+                    errors_text = json.dumps(poisoned_payload.get("errors", []), ensure_ascii=False) if poisoned_payload else ""
+                    if poisoned_payload.get("ok") is not False:
+                        failures.append(Failure("deep-existing-bootstrap", "`light-governance forbidden spec verify` must fail closed"))
+                    if ".loom/specs/INIT-0001/spec.md" not in errors_text:
+                        failures.append(Failure("deep-existing-bootstrap", "`light-governance forbidden spec verify` must name the unexpected spec carrier"))
     return failures
 
 

package/payload/skills/loom-resume/.loom-runtime/shared/scripts/loom_flow.py

@@ -3172,12 +3172,6 @@ def default_repo_interface() -> dict[str, Any]:
         "dynamic_tool_locators": [],
         "policy_locators": [],
         "hook_locators": [],
-        "release_targets": {
-            "catalog_locator": ".loom/companion/releases/catalog.json",
-            "current_target_locator": ".loom/companion/releases/current.json",
-            "enforcement": "blocking",
-            "status_locator": ".loom/companion/releases/status.json",
-        },
     }
 
 
@@ -3237,10 +3231,6 @@ def companion_text_payloads() -> dict[str, str]:
         ".loom/companion/merge-ready.md": "# Companion Merge-Ready Surface\n",
         ".loom/companion/closeout.md": "# Companion Closeout Surface\n",
         ".loom/companion/checkpoints.md": "# Companion Checkpoints\n",
-        ".loom/companion/releases/changelog.md": "# Changelog\n\n- Bootstrap release intake example.\n",
-        ".loom/companion/releases/release-notes.md": "# Release Notes\n\n- Bootstrap release target is ready for Loom-derived status consumption.\n",
-        ".loom/companion/releases/migration-notes.md": "# Migration Notes\n\n- not_applicable\n",
-        ".loom/companion/releases/rollback.md": "# Rollback Basis\n\n- Revert the companion-owned release target declaration and rerun Loom checks.\n",
     }
 
 
@@ -3249,48 +3239,6 @@ def companion_json_payloads() -> dict[str, dict[str, Any]]:
         ".loom/companion/manifest.json": default_companion_manifest(),
         ".loom/companion/repo-interface.json": default_repo_interface(),
         ".loom/companion/interop.json": default_repo_interop(),
-        ".loom/companion/releases/catalog.json": {
-            "schema_version": "loom-target-release-catalog/v1",
-            "current_release_id": "bootstrap-v0.1.0",
-            "releases": [
-                {
-                    "release_id": "bootstrap-v0.1.0",
-                    "locator": ".loom/companion/releases/current.json",
-                }
-            ],
-        },
-        ".loom/companion/releases/current.json": {
-            "schema_version": "loom-target-release/v1",
-            "release_id": "bootstrap-v0.1.0",
-            "display_name": "Bootstrap v0.1.0",
-            "target_branch": "main",
-            "release_goal": "Bootstrap the first executable Loom path for this repository.",
-            "status": "unreleased",
-            "included_scope": {
-                "phase": [{"id": "bootstrap-phase", "locator": ".loom/companion/checkpoints.md", "delivery_status": "planned"}],
-                "fr": [],
-                "work_item": [{"id": "INIT-0001", "locator": ".loom/work-items/INIT-0001.md", "delivery_status": "unmerged"}],
-                "implementation_pr": [],
-                "merge_commit": [],
-            },
-            "evidence": {
-                "changelog_locator": ".loom/companion/releases/changelog.md",
-                "release_notes_locator": ".loom/companion/releases/release-notes.md",
-                "migration_notes_locator": ".loom/companion/releases/migration-notes.md",
-                "tag_or_artifact_locator": ".loom/companion/README.md",
-                "rollback_basis_locator": ".loom/companion/releases/rollback.md",
-            },
-            "authority": {
-                "owner": "repo-companion",
-                "source_kind": "repo_owned_locator",
-                "source_locator": ".loom/companion/releases/current.json",
-            },
-        },
-        ".loom/companion/releases/status.json": {
-            "schema_version": "loom-target-release-status/v1",
-            "result": "pass",
-            "summary": "repo-owned release status example is readable.",
-        },
     }