@harmonyos-arkts/d2h 0.1.27 → 0.1.29

package/skills/d2h-architecture-plan/scripts/test_architecture_plan.py

@@ -1,8 +1,6 @@
-"""Behavior checks for the dashboard selection boundary; no real project is touched."""
+"""Final-display contract checks. No source or HarmonyOS project is touched."""
 
 import copy
-import contextlib
-import io
 import json
 import os
 from pathlib import Path
@@ -10,10 +8,8 @@ import subprocess
 import sys
 import tempfile
 import unittest
-from unittest.mock import patch
 
-import architecture_plan as helper
-from architecture_plan import ContractError, apply_selection, read_selection, validate_plan
+from architecture_plan import ContractError, directory_tree, load_json, validate_plan
 
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
@@ -22,356 +18,223 @@ HELPER = SKILL_ROOT / "scripts" / "architecture_plan.py"
 
 class ArchitecturePlanTests(unittest.TestCase):
     def setUp(self):
-        self.plan = json.loads((SKILL_ROOT / "references" / "architecture-plan.example.json").read_text(encoding="utf-8"))
-        self.decision = {
-            "requestId": "request-1", "planId": self.plan["planId"],
-            "selectedProposalId": "android-mirror",
-            "action": "select-and-create", "source": "dashboard", "notes": "",
-        }
+        self.plan = load_json(SKILL_ROOT / "references" / "architecture-plan.example.json")
 
-    def test_example_has_three_independently_valid_trees_and_no_user_selection(self):
-        validate_plan(self.plan)
-        self.assertEqual({p["id"] for p in self.plan["proposals"]}, {"android-mirror", "harmony-practice", "hybrid"})
-        self.assertIsNone(self.plan["selectedProposalId"])
-
-    def test_minimal_content_needs_no_execution_paths_or_architecture_relationship_models(self):
-        self.plan["androidAnalysis"]["risks"] = []
-        validate_plan(self.plan)
-        self.assertEqual(set(self.plan["androidAnalysis"]), {"summary", "techStack", "risks"})
-        self.assertEqual(set(self.plan["project"]), {"name", "summary"})
-        for proposal in self.plan["proposals"]:
-            self.assertEqual(set(proposal), {"id", "name", "summary", "directoryTree"})
-        updated, result = apply_selection(self.plan, self.decision)
-        self.assertEqual(result["nextAction"], "create-directory-shell")
-        self.assertEqual(updated["androidAnalysis"], self.plan["androidAnalysis"])
-
-    def test_selecting_nonrecommended_scheme_does_not_change_recommendation_or_trees(self):
-        original = copy.deepcopy(self.plan)
-        updated, result = apply_selection(self.plan, self.decision)
-        self.assertEqual(self.plan, original)
-        self.assertEqual(updated["recommendedProposalId"], "hybrid")
-        self.assertEqual(updated["selectedProposalId"], "android-mirror")
-        self.assertEqual(updated["proposals"], original["proposals"])
-        self.assertNotIn("selection", updated)
-        proposal, confirmation = read_selection(updated, self.decision)
-        self.assertEqual(proposal, updated["proposals"][0])
-        self.assertEqual(confirmation["requestId"], self.decision["requestId"])
-        self.assertEqual(result["nextAction"], "create-directory-shell")
-        validate_plan(updated)
-
-    def test_select_only_does_not_instruct_creation(self):
-        self.decision["action"] = "select"
-        updated, result = apply_selection(self.plan, self.decision)
-        self.assertEqual(result["nextAction"], "selection-recorded")
-        self.assertEqual(updated["selectedProposalId"], "android-mirror")
+    def nodes(self):
+        def visit(node):
+            yield node
+            for child in node["children"]:
+                yield from visit(child)
+        return list(visit(self.plan["directoryTree"]))
 
-    def test_exact_retry_does_not_change_plan(self):
-        updated, _ = apply_selection(self.plan, self.decision)
-        retry, result = apply_selection(updated, self.decision, self.decision)
-        self.assertEqual(retry, updated)
-        self.assertEqual(result["status"], "already-applied")
+    def node(self, path):
+        return next(node for node in self.nodes() if node["path"] == path)
 
-    def test_request_id_cannot_be_reused_with_changed_content(self):
-        updated, _ = apply_selection(self.plan, self.decision)
-        for key, value in (("selectedProposalId", "hybrid"), ("action", "select"), ("notes", "changed")):
-            changed = {**self.decision, key: value}
-            with self.subTest(key=key), self.assertRaisesRegex(ContractError, "requestId"):
-                apply_selection(updated, changed, self.decision)
+    def cli(self, *args, env=None):
+        return subprocess.run([sys.executable, "-X", "utf8", "-B", str(HELPER), *map(str, args)],
+                              capture_output=True, encoding="utf-8", env=env, check=False)
 
-    def test_new_request_can_change_the_selected_scheme(self):
-        updated, _ = apply_selection(self.plan, self.decision)
-        changed = {**self.decision, "requestId": "request-2", "selectedProposalId": "harmony-practice"}
-        final, result = apply_selection(updated, changed, self.decision)
-        self.assertEqual(result["status"], "applied")
-        self.assertEqual(final["selectedProposalId"], "harmony-practice")
-        _, confirmation = read_selection(final, changed)
-        self.assertEqual(confirmation["selectedProposalId"], "harmony-practice")
-
-    def test_wrong_plan_scheme_action_and_extra_paths_are_rejected(self):
-        for key, value in (
-            ("planId", "another-project"), ("planId", True),
-            ("selectedProposalId", "unknown"), ("action", "run-command"),
-            ("targetRoot", "E:/other"), ("directoryTree", {}),
-        ):
-            with self.subTest(key=key), self.assertRaises(ContractError):
-                apply_selection(self.plan, {**self.decision, key: value})
-        self.assertIsNone(self.plan["selectedProposalId"])
-
-    def test_plan_and_callback_only_need_content_and_selection_metadata(self):
-        self.assertEqual(set(self.plan), {
-            "planId", "project", "androidAnalysis", "proposals", "recommendedProposalId",
-            "recommendationReason", "selectedProposalId",
-        })
-        self.assertEqual(set(self.decision), {
-            "requestId", "planId", "selectedProposalId", "action", "source", "notes",
-        })
+    def test_example_is_one_final_tree_with_decision_notes(self):
+        before = copy.deepcopy(self.plan)
         validate_plan(self.plan)
-        updated, _ = apply_selection(self.plan, self.decision)
-        self.assertEqual(set(updated), set(self.plan))
-
-    def test_fixed_analysis_fields_and_concise_risk_cards_are_validated(self):
-        stack = self.plan["androidAnalysis"]["techStack"]
-        invalid = (
-            {"techStack": "Kotlin"}, {"techStack": [""]},
-            {"techStack": {key: value for key, value in stack.items() if key != "storage"}},
-            {"techStack": {**stack, "ui": ""}},
-            {"techStack": {**stack, "language": ["Kotlin", "Java"]}},
-            {"techStack": {**stack, "frameworks": "extra category"}},
-            {"risks": ["long unstructured risk"]},
-            {"risks": [{"title": "存储适配", "impact": ""}]},
-            {"risks": [{"title": "存储适配"}]},
-            {"risks": [{"title": "存储适配", "impact": "需核验", "answerRequired": True}]},
-            {"risks": [{"title": str(index), "impact": "影响"} for index in range(6)]},
-        )
-        for fields in invalid:
-            with self.subTest(fields=fields), self.assertRaises(ContractError):
-                validate_plan({**self.plan, "androidAnalysis": {**self.plan["androidAnalysis"], **fields}})
-
-    def test_removed_fields_are_not_reintroduced_into_compact_contract(self):
-        cases = (("project", "targetRoot"), ("project", "scope"), ("androidAnalysis", "regions"),
-                 ("androidAnalysis", "structure"), ("androidAnalysis", "openQuestions"),
-                 ("androidAnalysis", "dependencies"), ("proposal", "mappings"),
-                 ("proposal", "dependencies"), ("proposal", "sharedOwners"),
-                 ("proposal", "benefits"), ("proposal", "costs"), ("proposal", "risks"))
-        for section, field in cases:
-            broken = copy.deepcopy(self.plan)
-            value = broken["proposals"][0] if section == "proposal" else broken[section]
-            value[field] = []
-            with self.subTest(section=section, field=field), self.assertRaisesRegex(ContractError, "unknown fields"):
-                validate_plan(broken)
+        self.assertEqual(self.plan, before)
+        self.assertEqual(set(self.plan), {"projectName", "directoryTree", "decisions"})
+        paths = directory_tree(self.plan["directoryTree"])
+        self.assertIn("entry/src/main/ets/features/mail/messageview", paths)
+        self.assertNotIn("products/thunderbird", paths)
+        self.assertTrue(self.plan["decisions"])
+
+    def test_missing_extra_and_legacy_top_fields_are_rejected(self):
+        for key in self.plan:
+            changed = copy.deepcopy(self.plan)
+            del changed[key]
+            with self.subTest(missing=key), self.assertRaises(ContractError):
+                validate_plan(changed)
+        for key in ("project", "androidAnalysis", "proposals", "recommendedProposalId", "recommendationReason",
+                    "selectedProposalId", "selection", "planId", "revision", "schemaVersion", "targetRoot", "dependencies"):
+            with self.subTest(extra=key), self.assertRaises(ContractError):
+                validate_plan({**self.plan, key: None})
+
+    def test_project_name_and_decision_fields_must_be_nonempty_text(self):
+        for value in (None, True, 0, [], {}, "", " \n"):
+            with self.subTest(projectName=value), self.assertRaises(ContractError):
+                validate_plan({**self.plan, "projectName": value})
+            for key in ("title", "description"):
+                changed = copy.deepcopy(self.plan)
+                changed["decisions"][0][key] = value
+                with self.subTest(decision=key, value=value), self.assertRaises(ContractError):
+                    validate_plan(changed)
+
+    def test_decisions_require_a_nonempty_exactly_shaped_array(self):
+        for value in (None, {}, "decision", [], [{}], [{"title": "保留"}],
+                      [{"title": "保留", "description": "原包族", "confirmed": True}]):
+            with self.subTest(value=value), self.assertRaises(ContractError):
+                validate_plan({**self.plan, "decisions": value})
+
+    def test_old_dependency_array_and_embedded_relationship_fields_are_rejected(self):
+        for value in ([], [{"fromPath": "entry", "toPath": "AppScope", "description": "旧关系模型"}]):
+            with self.subTest(value=value), self.assertRaises(ContractError):
+                validate_plan({**self.plan, "dependencies": value})
+        for key, value in (("fromPath", "entry"), ("toPath", "AppScope"), ("dependencies", [])):
+            changed = copy.deepcopy(self.plan)
+            changed["decisions"][0][key] = value
+            with self.subTest(key=key), self.assertRaises(ContractError):
+                validate_plan(changed)
+
+    def test_nodes_require_description_children_and_known_fields(self):
+        for key in ("name", "path", "description", "children"):
+            changed = copy.deepcopy(self.plan)
+            del changed["directoryTree"][key]
+            with self.subTest(missing=key), self.assertRaises(ContractError):
+                validate_plan(changed)
+        for key, value in (("description", ""), ("children", {}), ("kind", "module"),
+                           ("kind", None), ("selected", True)):
+            changed = copy.deepcopy(self.plan)
+            changed["directoryTree"][key] = value
+            with self.subTest(key=key), self.assertRaises(ContractError):
+                validate_plan(changed)
 
-    def test_invalid_paths_case_collisions_and_skipped_levels_are_rejected(self):
-        for path in ("../escape", "/absolute", "E:/absolute", "a\\b", "a//b", "a/./b", "a/../b", "NUL", "x.", "{pages,state}", "a/b"):
-            broken = copy.deepcopy(self.plan)
-            leaf = broken["proposals"][0]["directoryTree"]["children"][0]
-            leaf["path"] = path
-            leaf["name"] = path.split("/")[-1]
+    def test_root_is_a_normal_directory_at_dot(self):
+        for key, value in (("path", "entry"), ("kind", "HAP")):
+            changed = copy.deepcopy(self.plan)
+            changed["directoryTree"][key] = value
+            with self.subTest(key=key), self.assertRaises(ContractError):
+                validate_plan(changed)
+
+    def test_names_and_direct_nesting_must_match_paths(self):
+        for path, name in (("entry/src/main", "main"), ("entry/src", "sources")):
+            changed = copy.deepcopy(self.plan)
+            node = changed["directoryTree"]["children"][1]["children"][0]
+            node.update(path=path, name=name)
+            with self.subTest(path=path, name=name), self.assertRaises(ContractError):
+                validate_plan(changed)
+
+    def test_unsafe_and_placeholder_paths_are_rejected(self):
+        for path in ("/absolute", "E:/target", "../source", "a/../b", "a//b", "./entry", "a\\b",
+                     "pages/*", "{pages,state}", "<产品>", "…", "CON", "NUL.txt", "aux", "COM¹", "lpt².log", "a.", "a ",
+                     "bad\x00path", "bad?path"):
+            changed = copy.deepcopy(self.plan)
+            changed["directoryTree"]["children"][0].update(path=path, name=path.split("/")[-1])
             with self.subTest(path=path), self.assertRaises(ContractError):
-                validate_plan(broken)
-        root = self.plan["proposals"][0]["directoryTree"]
-        root["children"].append({"name": "ENTRY", "path": "ENTRY", "description": "collision", "kind": "directory", "children": []})
-        with self.assertRaisesRegex(ContractError, "case-conflicting"):
+                validate_plan(changed)
+
+    def test_duplicate_and_case_conflicting_paths_are_rejected(self):
+        for name in ("AppScope", "appscope"):
+            changed = copy.deepcopy(self.plan)
+            duplicate = copy.deepcopy(changed["directoryTree"]["children"][0])
+            duplicate.update(name=name, path=name)
+            changed["directoryTree"]["children"].append(duplicate)
+            with self.subTest(name=name), self.assertRaisesRegex(ContractError, "duplicate/case-conflicting"):
+                validate_plan(changed)
+
+    def test_application_hap_and_expanded_production_root_are_required(self):
+        changed = copy.deepcopy(self.plan)
+        changed["directoryTree"]["children"] = []
+        with self.assertRaisesRegex(ContractError, "application HAP"):
+            validate_plan(changed)
+        self.node("entry")["kind"] = "HAR"
+        with self.assertRaisesRegex(ContractError, "application HAP"):
             validate_plan(self.plan)
-
-    def test_nested_module_and_missing_child_array_are_rejected(self):
-        entry = self.plan["proposals"][0]["directoryTree"]["children"][1]
-        entry["children"][0]["kind"] = "HAR"
-        with self.assertRaisesRegex(ContractError, "nested module"):
-            validate_plan(self.plan)
-        entry["children"][0]["kind"] = "directory"
-        del entry["children"][0]["children"]
-        with self.assertRaises(ContractError):
+        self.node("entry")["kind"] = "HAP"
+        self.node("entry")["children"] = []
+        with self.assertRaisesRegex(ContractError, "src/main"):
             validate_plan(self.plan)
 
-    def test_empty_tree_or_tree_without_application_module_is_rejected(self):
-        for mode in ("empty", "no-hap", "hap-without-source"):
-            broken = copy.deepcopy(self.plan)
-            tree = broken["proposals"][0]["directoryTree"]
-            if mode == "empty":
-                tree["children"] = []
-            elif mode == "no-hap":
-                tree["children"][1].pop("kind")
-            else:
-                tree["children"][1]["children"] = []
-            with self.subTest(mode=mode), self.assertRaises(ContractError):
-                validate_plan(broken)
-
-    def test_read_preserves_user_notes_for_implementation_review(self):
-        answer = {**self.decision, "notes": "保留现有目录，只补充风险说明。"}
-        selected, _ = apply_selection(self.plan, answer)
-        _, result = read_selection(selected, answer)
-        self.assertEqual(result["notes"], answer["notes"])
-
-    def test_new_submission_cannot_overwrite_the_confirmation_input_in_place(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, saved_file = root / "architecture-plan.json", root / "architecture-selection.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            saved_file.write_text(json.dumps(self.decision), encoding="utf-8")
-            original = plan_file.read_bytes()
-            result = self.run_cli("apply-selection", plan_file, saved_file)
-            self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
-            self.assertEqual(plan_file.read_bytes(), original)
-
-    def test_required_content_scheme_identity_and_selection_consistency_are_checked(self):
-        mutations = (
-            lambda p: p["project"].pop("summary"),
-            lambda p: p["androidAnalysis"].pop("risks"),
-            lambda p: p["androidAnalysis"].pop("techStack"),
-            lambda p: p["androidAnalysis"].update(risks="unknown"),
-            lambda p: p["proposals"][1].pop("directoryTree"),
-            lambda p: p["proposals"].pop(),
-            lambda p: p["proposals"][0].update(id="hybrid"),
-            lambda p: p.update(selectedProposalId="unknown"),
-            lambda p: p.update(selection=None),
-        )
-        for index, mutate in enumerate(mutations):
-            broken = copy.deepcopy(self.plan)
-            mutate(broken)
-            with self.subTest(index=index), self.assertRaises(ContractError):
-                validate_plan(broken)
-
-    def run_cli(self, *args):
-        return subprocess.run([sys.executable, str(HELPER), *map(str, args)],
-                              capture_output=True, text=True, encoding="utf-8", timeout=10)
-
-    def test_dashboard_and_question_use_the_same_durable_confirmation_and_read_step(self):
-        for source in ("dashboard", "question"):
-            with self.subTest(source=source), tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                plan_file, answer_file = root / "architecture-plan.json", root / "tool-answer.json"
-                saved_file = root / "architecture-selection.json"
-                plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-                answer = {**self.decision, "source": source}
-                answer_file.write_text(json.dumps(answer), encoding="utf-8")
-                applied = self.run_cli("apply-selection", plan_file, answer_file)
-                self.assertEqual(applied.returncode, 0, applied.stdout + applied.stderr)
-                self.assertEqual(json.loads(saved_file.read_text(encoding="utf-8")), answer)
-                saved_plan = json.loads(plan_file.read_text(encoding="utf-8"))
-                self.assertEqual(saved_plan["selectedProposalId"], answer["selectedProposalId"])
-                self.assertNotIn("selection", saved_plan)
-                resumed = self.run_cli("read-selection", plan_file)
-                self.assertEqual(resumed.returncode, 0, resumed.stdout + resumed.stderr)
-                output = json.loads(resumed.stdout)
-                self.assertEqual(output["source"], source)
-                self.assertEqual(output["nextAction"], "create-directory-shell")
-                self.assertEqual(output["selectedProposalId"], "android-mirror")
-                self.assertEqual({p.name for p in root.iterdir()}, {plan_file.name, answer_file.name, saved_file.name})
-
-    def test_read_rejects_unconfirmed_or_mismatched_selection(self):
-        with self.assertRaisesRegex(ContractError, "no confirmed"):
-            read_selection(self.plan, self.decision)
-        updated, _ = apply_selection(self.plan, self.decision)
-        for key, value in (("planId", "other-plan"), ("selectedProposalId", "hybrid")):
-            with self.subTest(key=key), self.assertRaisesRegex(ContractError, "does not match"):
-                read_selection(updated, {**self.decision, key: value})
-
-    def test_read_select_only_never_requests_creation(self):
-        answer = {**self.decision, "action": "select", "source": "question"}
-        updated, _ = apply_selection(self.plan, answer)
-        _, result = read_selection(updated, answer)
-        self.assertEqual(result["nextAction"], "selection-recorded")
-
-    def test_missing_confirmation_file_prevents_directory_implementation(self):
-        with tempfile.TemporaryDirectory() as directory:
-            plan_file = Path(directory) / "architecture-plan.json"
-            selected, _ = apply_selection(self.plan, self.decision)
-            plan_file.write_text(json.dumps(selected), encoding="utf-8")
-            result = self.run_cli("read-selection", plan_file)
-            self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
-            self.assertEqual(json.loads(result.stdout)["status"], "error")
-
-    def test_recovery_applies_saved_question_answer_before_reading_implementation_input(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, saved_file = root / "architecture-plan.json", root / "architecture-selection.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            answer = {**self.decision, "source": "question"}
-            saved_file.write_text(json.dumps(answer), encoding="utf-8")
-            pending = self.run_cli("read-selection", plan_file)
-            self.assertEqual(pending.returncode, 1)
-            recovered = self.run_cli("apply-selection", plan_file, saved_file, "--recover")
-            self.assertEqual(recovered.returncode, 0, recovered.stdout + recovered.stderr)
-            ready = self.run_cli("read-selection", plan_file)
-            self.assertEqual(ready.returncode, 0, ready.stdout + ready.stderr)
-            self.assertEqual(json.loads(ready.stdout)["source"], "question")
-
-    def test_cli_retries_without_writing_and_never_creates_target(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            target = root / "not-created"
-            plan_file, decision_file = root / "architecture-plan.json", root / "incoming-selection.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            decision_file.write_text(json.dumps(self.decision), encoding="utf-8-sig")
-            result = self.run_cli("apply-selection", plan_file, decision_file)
-            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
-            self.assertEqual(json.loads(result.stdout)["nextAction"], "create-directory-shell")
-            first_write = plan_file.stat().st_mtime_ns
-            retry = self.run_cli("apply-selection", plan_file, decision_file)
-            self.assertEqual(retry.returncode, 0, retry.stdout + retry.stderr)
-            self.assertEqual(json.loads(retry.stdout)["status"], "already-applied")
-            self.assertEqual(plan_file.stat().st_mtime_ns, first_write)
-            self.assertFalse(target.exists())
-            self.assertEqual({p.name for p in root.iterdir()}, {plan_file.name, decision_file.name, "architecture-selection.json"})
-
-    def test_changed_retry_is_rejected_without_replacing_confirmation(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, incoming = root / "architecture-plan.json", root / "incoming.json"
-            saved = root / "architecture-selection.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            incoming.write_text(json.dumps(self.decision), encoding="utf-8")
-            self.assertEqual(self.run_cli("apply-selection", plan_file, incoming).returncode, 0)
-            plan_bytes, confirmed_bytes = plan_file.read_bytes(), saved.read_bytes()
-            incoming.write_text(json.dumps({**self.decision, "action": "select"}), encoding="utf-8")
-            rejected = self.run_cli("apply-selection", plan_file, incoming)
-            self.assertEqual(rejected.returncode, 1, rejected.stdout)
-            self.assertIn("requestId", json.loads(rejected.stdout)["error"])
-            self.assertEqual(plan_file.read_bytes(), plan_bytes)
-            self.assertEqual(saved.read_bytes(), confirmed_bytes)
-
-    def test_recovery_flag_requires_the_script_owned_confirmation(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, incoming = root / "architecture-plan.json", root / "incoming.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            incoming.write_text(json.dumps(self.decision), encoding="utf-8")
-            rejected = self.run_cli("apply-selection", plan_file, incoming, "--recover")
-            self.assertEqual(rejected.returncode, 1)
-            self.assertFalse((root / "architecture-selection.json").exists())
-
-    def test_failed_plan_write_cannot_enter_implementation_and_can_recover(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, incoming = root / "architecture-plan.json", root / "incoming.json"
-            saved = root / "architecture-selection.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            incoming.write_text(json.dumps(self.decision), encoding="utf-8")
-            original = plan_file.read_bytes()
-            save_json = helper.save_json
-
-            def fail_plan_write(path, value):
-                if path == plan_file:
-                    raise OSError("simulated plan write failure")
-                save_json(path, value)
+    def test_empty_hap_production_root_is_rejected(self):
+        self.node("entry/src/main")["children"] = []
+        with self.assertRaisesRegex(ContractError, "src/main"):
+            validate_plan(self.plan)
 
-            arguments = [str(HELPER), "apply-selection", str(plan_file), str(incoming)]
-            with patch.object(sys, "argv", arguments), patch.object(helper, "save_json", side_effect=fail_plan_write):
-                with contextlib.redirect_stdout(io.StringIO()):
-                    self.assertEqual(helper.main(), 1)
-            self.assertEqual(plan_file.read_bytes(), original)
-            self.assertEqual(json.loads(saved.read_text(encoding="utf-8")), self.decision)
-            self.assertEqual(self.run_cli("read-selection", plan_file).returncode, 1)
-            recovered = self.run_cli("apply-selection", plan_file, saved, "--recover")
-            self.assertEqual(recovered.returncode, 0, recovered.stdout + recovered.stderr)
-            self.assertEqual(self.run_cli("read-selection", plan_file).returncode, 0)
+    def test_hap_tree_validation_is_not_tied_to_one_source_language(self):
+        for name in ("js", "cpp"):
+            changed = copy.deepcopy(self.plan)
+            source = next(node for node in self.nodes() if node["path"] == "entry/src/main/ets")
+            source = copy.deepcopy(source)
+            def rebase(node):
+                node["path"] = node["path"].replace("entry/src/main/ets", f"entry/src/main/{name}", 1)
+                for child in node["children"]:
+                    rebase(child)
+            rebase(source)
+            source["name"] = name
+            changed["directoryTree"]["children"][1]["children"][0]["children"][0]["children"][0] = source
+            with self.subTest(source=name):
+                validate_plan(changed)
+
+    def test_module_cannot_be_inside_another_modules_source_tree(self):
+        for kind in ("HAP", "HAR", "HSP"):
+            self.node("entry/src/main/ets/features")["kind"] = kind
+            with self.subTest(kind=kind), self.assertRaisesRegex(ContractError, "source tree"):
+                validate_plan(self.plan)
+
+    def test_module_grouping_outside_a_source_tree_is_not_rejected_as_nesting(self):
+        self.node("entry")["children"].append({
+            "name": "libraries", "path": "entry/libraries", "description": "库目录分组", "children": [{
+                "name": "mail", "path": "entry/libraries/mail", "kind": "HAR",
+                "description": "由独立构建配置注册的库模块", "children": [{
+                    "name": "src", "path": "entry/libraries/mail/src", "description": "库源码", "children": [{
+                        "name": "main", "path": "entry/libraries/mail/src/main", "description": "生产根", "children": [{
+                            "name": "ets", "path": "entry/libraries/mail/src/main/ets",
+                            "description": "库的 ArkTS 源码", "children": [],
+                        }],
+                    }],
+                }],
+            }],
+        })
+        validate_plan(self.plan)
 
-    def test_reloaded_notes_are_utf8_even_with_an_ascii_console(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, incoming = root / "architecture-plan.json", root / "incoming.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            answer = {**self.decision, "notes": "保留目录，补充说明 📝"}
-            incoming.write_text(json.dumps(answer, ensure_ascii=False), encoding="utf-8")
-            self.assertEqual(self.run_cli("apply-selection", plan_file, incoming).returncode, 0)
-            result = subprocess.run([sys.executable, str(HELPER), "read-selection", str(plan_file)],
-                                    capture_output=True, timeout=10,
-                                    env={**os.environ, "PYTHONIOENCODING": "ascii"})
+    def test_multiple_hap_modules_and_sibling_libraries_are_supported(self):
+        for kind in ("HAP", "HAR", "HSP"):
+            with self.subTest(kind=kind):
+                changed = copy.deepcopy(self.plan)
+                module = copy.deepcopy(changed["directoryTree"]["children"][1])
+                def rebase(node):
+                    node["path"] = "second" + node["path"][len("entry"):]
+                    for child in node["children"]:
+                        rebase(child)
+                rebase(module)
+                module.update(name="second", kind=kind)
+                changed["directoryTree"]["children"].append(module)
+                validate_plan(changed)
+
+    def test_invalid_json_duplicate_keys_and_nonstandard_numbers_are_rejected(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "plan.json"
+            for content in ('{"projectName": "a", "projectName": "b"}', '{"bad": NaN}',
+                            '{"bad": Infinity}', '{"bad": -Infinity}', '{broken', 'null'):
+                path.write_text(content, encoding="utf-8")
+                with self.subTest(content=content), self.assertRaises(ValueError):
+                    validate_plan(load_json(path))
+
+    def test_cli_validates_utf8_bom_and_makes_no_writes_or_confirmation_files(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "architecture-plan.json"
+            path.write_text(json.dumps(self.plan, ensure_ascii=False), encoding="utf-8-sig")
+            before = path.read_bytes()
+            result = self.cli("validate", path, env={**os.environ, "PYTHONIOENCODING": "ascii"})
             self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
-            self.assertEqual(json.loads(result.stdout.decode("utf-8"))["notes"], answer["notes"])
-
-    def test_cli_error_leaves_plan_bytes_unchanged_and_returns_structured_error(self):
-        with tempfile.TemporaryDirectory() as directory:
-            root = Path(directory)
-            plan_file, decision_file = root / "plan.json", root / "decision.json"
-            plan_file.write_text(json.dumps(self.plan), encoding="utf-8")
-            original = plan_file.read_bytes()
-            for content in (json.dumps({**self.decision, "planId": "other-plan"}), '{"action":"select","action":"select-and-create"}', '[]', '{invalid'):
-                decision_file.write_text(content, encoding="utf-8")
-                result = self.run_cli("apply-selection", plan_file, decision_file)
-                self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
+            self.assertEqual(json.loads(result.stdout), {"status": "valid", "projectName": "示例邮件客户端"})
+            self.assertEqual(path.read_bytes(), before)
+            self.assertEqual([p.name for p in path.parent.iterdir()], [path.name])
+
+    def test_cli_errors_do_not_rewrite_input_and_missing_file_is_reported(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            path = Path(temporary) / "architecture-plan.json"
+            for content in ('{"proposals": []}', '{broken', '[]'):
+                path.write_text(content, encoding="utf-8")
+                result = self.cli("validate", path)
+                self.assertEqual(result.returncode, 1)
                 self.assertEqual(json.loads(result.stdout)["status"], "error")
-                self.assertEqual(plan_file.read_bytes(), original)
+                self.assertEqual(path.read_text(encoding="utf-8"), content)
+            result = self.cli("validate", path.parent / "missing.json")
+            self.assertEqual(result.returncode, 1)
+            self.assertEqual(json.loads(result.stdout)["status"], "error")
+
+    def test_legacy_selection_commands_are_unavailable(self):
+        for command in ("apply-selection", "read-selection"):
+            result = self.cli(command, "architecture-plan.json")
+            with self.subTest(command=command):
+                self.assertNotEqual(result.returncode, 0)
+                self.assertIn("invalid choice", result.stderr)
 
 
 if __name__ == "__main__":

package/skills/d2h-spec-develop/SKILL.md

@@ -5,7 +5,7 @@ description: Implement ordered Android-to-HarmonyOS page tasks from pages.json,
 
 # Page development loop
 
-Each page-worker implements only the selected page and brings its build to a pass. After development is complete, the parent agent takes over testing, defect fixes, and acceptance for the current task.
+Each page-worker implements only the selected page and brings its build to a pass. After development is complete, the parent agent takes over testing, defect fixes, and acceptance for the current task. A worker may be reused for a fixed ordered group of up to three related Specs. Implement one assigned task per handoff; the parent accepts it before authorizing the same worker to continue with the next member. Task identities, states, evidence and acceptance remain separate. Reuse is conditional on the host supporting child-session continuation and the parent confirming that the next task shares relevant context, the worker can use the refreshed baseline and interfaces, and no unresolved task or ownership conflict remains. Otherwise, explicitly revise the group and dispatch a fresh worker for the remaining scope.
 
 ## Inputs and boundaries
 
@@ -21,17 +21,18 @@ Each page-worker implements only the selected page and brings its build to a pas
 ## Parent-agent mode
 
 1. Read `pages.json` and `batch_report.json`; verify task identities, Spec paths and dependencies against pages.json, and use ledger planning for development scope and execution order. Verify planning references, counts and states. Reject missing, stale or invalid planning instead of falling back to all tasks when a selected scope or planning is present.
-2. Select the earliest eligible task in planning milestone/wave order (or legacy ledger tasks order when allowed) whose development/build/validation states are not `implemented/passed/passed` and whose declared dependencies are satisfied.
+2. Select the earliest eligible task in planning milestone/wave order (or legacy ledger tasks order when allowed) whose development/build/validation states are not `implemented/passed/passed` and whose declared dependencies are satisfied. When bound planning is present, the parent may group it with adjacent unfinished tasks in the same wave that share page, module or component context, normally two or three tasks and never more than three. Fix the ordered task IDs before dispatch; keep complex or unclear work as a single task and verify dependencies again before each member starts.
 3. Resolve the page package, Android root, HarmonyOS root, repository root, current `HEAD`, Git status, device target, and task evidence directory.
-4. Dispatch exactly one page-worker with absolute paths, selected task ID, dispatch baseline, device target, and evidence directory. Do not run page-workers in parallel. Wait for its result before the parent begins testing and fixes.
+4. Dispatch exactly one page-worker with absolute paths, the current task ID, ordered group task IDs when present, dispatch baseline, device target, and task evidence directory. Do not run page-workers in parallel. Wait for its result before the parent begins testing and fixes. Preserve the returned child-session identifier for possible continuation; use the host's actual resume parameter and confirm that the continuation returns the same session ID. A new child session is a fresh dispatch, not context reuse.
 5. After the worker returns, the parent takes ownership of the current page and executes testing and all fixes according to **Managed page tests and fixes** below until current build and required tests pass.
 6. Execute **Parent report and commits** below.
-7. Apply **Parent verification** below. Only after the page reaches `implemented/passed/passed`, evidence is current, and all page-owned changes are committed may the parent select the next page and dispatch a new worker.
+7. Apply **Parent verification** below. Only after the current page reaches `implemented/passed/passed`, evidence is current, and all page-owned changes are committed may the parent authorize the same worker to implement the next group member. Refresh its task package, baseline, permitted paths, dependency evidence and evidence directory. If continuation is unsupported or reuse review fails, explicitly revise the group and dispatch a fresh worker for the next eligible task with these refreshed inputs; lack of reuse support must not block normal serial development. If a member is blocked or the group becomes invalid, return to the parent with remaining tasks unchanged; do not skip members or expand the group. Dispatch a worker for a new group only after the current group closes or is explicitly revised.
 
 Use this worker prompt contract:
 
 ```text
 Use $d2h-spec-develop in page-worker mode. Complete the initial implementation and managed build for exactly <TASK_ID>.
+Assigned task IDs: <fixed ordered group of 1–3 task IDs; implement only TASK_ID until parent acceptance and explicit continuation>
 Skill path: <absolute path to this SKILL.md>
 Migration root: <absolute path>
 Page package: <absolute path>