@cannbot-plugin/cannbot-harness 0.0.0-stage → 0.1.5

package/assets/ops-direct-invoke/skills/ops-direct-invoke-maintain/test/ut/dsl_generation/test.py

@@ -0,0 +1,499 @@
+# ----------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------
+import copy
+import csv
+import importlib.util
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).absolute().parents[1]))
+import support
+from support import SCRIPTS, run_tests
+
+SCRIPT = SCRIPTS / "assemble_cannbotdsl_design.py"
+spec = importlib.util.spec_from_file_location("assemble_cannbotdsl_design", SCRIPT)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+
+contract_spec = importlib.util.spec_from_file_location(
+    "validate_unit_contracts", SCRIPTS / "validate_unit_contracts.py"
+)
+contracts = importlib.util.module_from_spec(contract_spec)
+contract_spec.loader.exec_module(contracts)
+
+
+def unit_fixture(uid, deps=(), files=()):
+    return {
+        "unit_id": uid,
+        "kind": "feature_increment",
+        "depends_on": list(deps),
+        "scope": {"source_files": list(files)},
+        "verification_obligations": [{"id": f"VO-{uid}", "kind": "numerical"}],
+    }
+
+
+class UnitContractTests(unittest.TestCase):
+    def test_transitive_capability_and_evidence_references(self):
+        native = {
+            "U01": unit_fixture("U01"),
+            "U02": unit_fixture("U02", ["U01"]),
+            "U03": unit_fixture("U03", ["U02"]),
+        }
+        native["U01"]["provides"] = ["base"]
+        native["U03"].update(
+            requires=["base"],
+            dependency_reasons={"U02": "increment"},
+            design_constraints=[
+                {
+                    "source": "DESIGN",
+                    "commitment": "base contract",
+                    "obligation_ids": ["VO-U01"],
+                }
+            ],
+        )
+        self.assertEqual(contracts.validate_units(native), ["U01", "U02", "U03"])
+        native["U03"]["requires"] = ["unprovided"]
+        with self.assertRaisesRegex(ValueError, "without dependency provider"):
+            contracts.validate_units(native)
+
+    def test_unknown_dependencies_and_cycles_rejected(self):
+        for native in (
+            {"U01": unit_fixture("U01", ["U02"])},
+            {"U01": unit_fixture("U01", ["U02"]), "U02": unit_fixture("U02", ["U01"])},
+        ):
+            with (
+                self.subTest(native=native),
+                self.assertRaisesRegex(ValueError, "unknown|cycle"),
+            ):
+                contracts.validate_units(native)
+
+    def test_unbound_design_rejected_and_review_contract_accepted(self):
+        unit = unit_fixture("U01")
+        unit["design_constraints"] = [
+            {"source": "DESIGN", "commitment": "execution domain"}
+        ]
+        with self.assertRaisesRegex(ValueError, "requires executable obligations"):
+            contracts.validate_units({"U01": unit})
+        unit["design_constraints"][0]["review_evidence"] = [
+            {
+                "artifact": "compiled kernel",
+                "check": "execution domain",
+                "pass_criteria": "declared domain used",
+            }
+        ]
+        self.assertEqual(contracts.validate_units({"U01": unit}), ["U01"])
+
+    def test_independent_unit_cannot_supply_evidence_reference(self):
+        native = {uid: unit_fixture(uid) for uid in ("U01", "U02")}
+        native["U02"]["design_constraints"] = [
+            {"source": "DESIGN", "commitment": "contract", "obligation_ids": ["VO-U01"]}
+        ]
+        with self.assertRaisesRegex(
+            ValueError, "invalid design_constraints obligation references"
+        ):
+            contracts.validate_units(native)
+
+    def test_feasibility_checks_need_actionable_evidence(self):
+        unit = unit_fixture("U01")
+        check = {
+            "design_source": "DESIGN",
+            "question": "combined data path",
+            "before_step": "first compute",
+            "on_failure": "return to DESIGN",
+        }
+        unit["implementation"] = {"feasibility_checks": [check]}
+        with self.assertRaisesRegex(ValueError, "requires executable obligations"):
+            contracts.validate_units({"U01": unit})
+        check["obligation_ids"] = ["VO-U01"]
+        self.assertEqual(contracts.validate_units({"U01": unit}), ["U01"])
+        check.pop("before_step")
+        with self.assertRaisesRegex(ValueError, "actionable contract fields"):
+            contracts.validate_units({"U01": unit})
+
+    def test_unit_kind_requires_matching_obligation(self):
+        for kind, evidence, missing in (
+            ("minimal_operator", "structural", "numerical"),
+            ("pipeline_framework", "numerical", "structural"),
+        ):
+            unit = unit_fixture("U01")
+            unit["kind"] = kind
+            unit["verification_obligations"][0]["kind"] = evidence
+            with (
+                self.subTest(kind=kind),
+                self.assertRaisesRegex(ValueError, f"lacks {missing}"),
+            ):
+                contracts.validate_units({"U01": unit})
+
+    def test_malformed_declarations_report_contract_errors(self):
+        original = unit_fixture("U01")
+        for key, invalid in (
+            ("depends_on", "U02"),
+            ("requires", [[], "bad"]),
+            ("verification_obligations", ["bad"]),
+            ("verification_obligations", [{"id": [], "kind": "numerical"}]),
+            ("verification_obligations", [{"id": "VO", "kind": []}]),
+        ):
+            unit = copy.deepcopy(original)
+            unit[key] = invalid
+            with self.subTest(key=key, invalid=invalid), self.assertRaises(ValueError):
+                contracts.validate_units({"U01": unit})
+
+    def test_duplicate_yaml_keys_cannot_hide_a_contract(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / "U01.yaml").write_text(
+                "unit:\n  unit_id: U01\n  requires: [missing]\n  requires: []\n"
+            )
+            with self.assertRaisesRegex(ValueError, "duplicate YAML key"):
+                contracts.load_units(tmp)
+
+
+class DesignAssemblyTests(unittest.TestCase):
+    def test_assembles_linked_topics_and_branches(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            design = Path(tmp)
+            (design / "INDEX.md").write_text(
+                "# Index\n[Overview](Overview.md)\n[B0](branches/DESIGN-BRANCH-B0.md)\n",
+                encoding="utf-8",
+            )
+            (design / "Overview.md").write_text("# Overview\nMath\n", encoding="utf-8")
+            (design / "branches").mkdir()
+            (design / "branches/DESIGN-BRANCH-B0.md").write_text(
+                "# B0\nPath\n", encoding="utf-8"
+            )
+            result = module.assemble(design)
+            self.assertIn("design source: Overview.md", result)
+            self.assertIn("design source: branches/DESIGN-BRANCH-B0.md", result)
+            self.assertLess(result.index("Math"), result.index("Path"))
+            self.assertNotIn("design source: INDEX.md", result)
+            self.assertIn("## Overview", result)
+
+    def test_index_sections_order_and_code_are_preserved(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            design = Path(tmp)
+            (design / "INDEX.md").write_text(
+                "# Operator\nNavigation only\n## Layout\n```text\n"
+                "[example](unused.md)\n```\n## Execution\n"
+                "[B1](branches/DESIGN-BRANCH-B1.md)\n"
+                "[Overview](Overview.md)\n"
+                "## Appendix\n[B0](branches/DESIGN-BRANCH-B0.md)\n",
+                encoding="utf-8",
+            )
+            code = "```python\n# Keep this comment\n```\n~~~text\n## Keep this too\n~~~"
+            (design / "Overview.md").write_text(
+                "# Overview\n## Detail\n" + code, encoding="utf-8"
+            )
+            (design / "branches").mkdir()
+            for name in ("B0", "B1"):
+                (design / f"branches/DESIGN-BRANCH-{name}.md").write_text(
+                    f"# {name}\n", encoding="utf-8"
+                )
+            result = module.assemble(design)
+            self.assertNotIn("Navigation only", result)
+            self.assertNotIn("## Layout", result)
+            self.assertNotIn("design source: INDEX.md", result)
+            self.assertIn("### Overview\n#### Detail", result)
+            self.assertIn(code, result)
+            headings = [
+                line
+                for line, in_code in module.markdown_lines(result)
+                if not in_code and line.startswith("#")
+            ]
+            self.assertEqual(
+                headings,
+                [
+                    "# Operator",
+                    "## Execution",
+                    "### B1",
+                    "### Overview",
+                    "#### Detail",
+                    "## Appendix",
+                    "### B0",
+                ],
+            )
+
+    def test_reference_documents_are_not_assembled(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            design = Path(tmp)
+            (design / "branches").mkdir()
+            (design / "INDEX.md").write_text(
+                "# add 设计索引\n## 1. 设计\n[Overview](Overview.md)\n"
+                "[P0](branches/DESIGN-BRANCH-P0.md)\n## 参考资料\n"
+                "[说明](Notes.md)\n[环境](../../environment/notes.md)\n",
+                encoding="utf-8",
+            )
+            for name in ("Overview.md", "branches/DESIGN-BRANCH-P0.md"):
+                (design / name).write_text("# Topic\nbody", encoding="utf-8")
+            (design / "REQUIREMENTS.md").write_text(
+                "requirements sentinel", encoding="utf-8"
+            )
+            (design / "Notes.md").write_text("reference sentinel", encoding="utf-8")
+            result = module.assemble(design)
+            self.assertTrue(result.startswith("# add 设计\n"))
+            self.assertNotIn("sentinel", result)
+            self.assertNotIn("## 参考资料", result)
+            self.assertNotIn("design source: INDEX.md", result)
+
+    def test_unlisted_branch_fails(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            design = Path(tmp)
+            (design / "INDEX.md").write_text(
+                "[Overview](Overview.md)\n", encoding="utf-8"
+            )
+            (design / "Overview.md").write_text("# Overview\n", encoding="utf-8")
+            (design / "branches").mkdir()
+            (design / "branches/DESIGN-BRANCH-B0.md").write_text(
+                "# B0\n", encoding="utf-8"
+            )
+            with self.assertRaisesRegex(ValueError, "branch links do not match"):
+                module.assemble(design)
+
+    def test_missing_linked_topic_fails(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            design = Path(tmp)
+            (design / "INDEX.md").write_text(
+                "[Overview](Overview.md)\n[B0](branches/DESIGN-BRANCH-B0.md)\n",
+                encoding="utf-8",
+            )
+            (design / "branches").mkdir()
+            (design / "branches/DESIGN-BRANCH-B0.md").write_text(
+                "# B0\n", encoding="utf-8"
+            )
+            with self.assertRaisesRegex(ValueError, "missing .*Overview.md"):
+                module.assemble(design)
+
+
+class UnitSubgraphTests(unittest.TestCase):
+    def generate_graph(self, native, work):
+        (work / "design/doc").mkdir(parents=True)
+        (work / "design/units").mkdir()
+        (work / "operators/add/test").mkdir(parents=True)
+        (work / "design/doc/spec.yaml").write_text("op: {name: add}\n")
+        (work / "design/doc/DESIGN.md").write_text("# add\n")
+        for uid, unit in native.items():
+            (work / f"design/units/{uid}.yaml").write_text(
+                yaml.safe_dump({"unit": unit})
+            )
+        with (work / "operators/add/test/testcase.csv").open("w", newline="") as handle:
+            writer = csv.DictWriter(
+                handle,
+                fieldnames=["sheet", "case_id", "unit_id", "status", "obligation_ids"],
+            )
+            writer.writeheader()
+            for uid in native:
+                writer.writerow(
+                    {
+                        "sheet": "tdd",
+                        "case_id": f"TD-{uid.lower()}-main",
+                        "unit_id": uid.lower(),
+                        "status": "active",
+                        "obligation_ids": f"VO-{uid}",
+                    }
+                )
+        result = subprocess.run(
+            [
+                sys.executable,
+                str(SCRIPTS / "build_implementation_subgraph.py"),
+                "--output-dir",
+                str(work),
+                "--harness-script",
+                str(support.HARNESS_SKILL / "scripts/get_task.py"),
+            ],
+            capture_output=True,
+            text=True,
+        )
+        return result
+
+    def test_conflict_order_follows_dependencies_instead_of_file_number(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            native = {
+                "U01": unit_fixture("U01", ["U02"], ["operators/add/add.py"]),
+                "U02": unit_fixture("U02", files=["operators/add/add.py"]),
+            }
+            result = self.generate_graph(native, work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            nodes = yaml.safe_load(
+                (work / ".workflow/implementation-tasks.yaml").read_text()
+            )["nodes"]
+            self.assertEqual(
+                [node["id"] for node in nodes[:2]], ["implement-u02", "implement-u01"]
+            )
+            self.assertEqual(nodes[0]["depends_on"], [])
+            self.assertEqual(nodes[1]["depends_on"], ["implement-u02"])
+
+    def test_disjoint_writes_parallel_and_unknown_writes_serial(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            native = {
+                "U01": unit_fixture("U01", files=["operators/add/a.py"]),
+                "U02": unit_fixture("U02", files=["operators/add/b.py"]),
+                "U03": unit_fixture("U03"),
+            }
+            result = self.generate_graph(native, work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            nodes = yaml.safe_load(
+                (work / ".workflow/implementation-tasks.yaml").read_text()
+            )["nodes"]
+            self.assertEqual(nodes[0]["depends_on"], [])
+            self.assertEqual(nodes[1]["depends_on"], [])
+            self.assertEqual(nodes[2]["depends_on"], ["implement-u01", "implement-u02"])
+
+    def test_path_aliases_still_serialize_shared_writes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            native = {
+                "U01": unit_fixture("U01", files=["operators/add/add.py"]),
+                "U02": unit_fixture(
+                    "U02", files=[str(work / "operators/add/../add/add.py")]
+                ),
+            }
+            result = self.generate_graph(native, work)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            nodes = yaml.safe_load(
+                (work / ".workflow/implementation-tasks.yaml").read_text()
+            )["nodes"]
+            self.assertEqual(nodes[1]["depends_on"], ["implement-u01"])
+
+    def test_invalid_planning_contract_blocked_before_scheduling(self):
+        for invalid in ("capability", "evidence"):
+            with self.subTest(invalid=invalid), tempfile.TemporaryDirectory() as tmp:
+                work = Path(tmp)
+                unit = unit_fixture("U01")
+                if invalid == "capability":
+                    unit["requires"] = ["missing"]
+                else:
+                    unit["design_constraints"] = [
+                        {"source": "DESIGN", "commitment": "execution domain"}
+                    ]
+                result = self.generate_graph({"U01": unit}, work)
+                self.assertNotEqual(result.returncode, 0)
+                self.assertFalse(
+                    (work / ".workflow/implementation-tasks.yaml").exists()
+                )
+
+    def test_native_unit_without_hash_generates_implementation_graph(self):
+        self.check_unit_graph()
+
+    def test_excluded_cases_do_not_block_active_obligation_coverage(self):
+        self.check_unit_graph(excluded=True)
+
+    def test_excluded_cases_cannot_replace_active_obligation_coverage(self):
+        self.check_unit_graph(excluded=True, active=False)
+
+    def check_unit_graph(self, excluded=False, active=True):
+        script = SCRIPTS / "build_implementation_subgraph.py"
+        harness = support.HARNESS_SKILL / "scripts/get_task.py"
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp)
+            (work / "design/doc").mkdir(parents=True)
+            (work / "design/units").mkdir()
+            (work / "operators/add/test").mkdir(parents=True)
+            (work / "design/doc/spec.yaml").write_text(
+                "op: {name: add}\n", encoding="utf-8"
+            )
+            (work / "design/doc/DESIGN.md").write_text("# add\n", encoding="utf-8")
+            unit = {
+                "unit": {
+                    "unit_id": "U01",
+                    "kind": "minimal_operator",
+                    "design_sources": [{"file": "Kernel.md", "section": "Compute"}],
+                    "depends_on": [],
+                    "scope": {"source_files": ["operators/add/add.py"]},
+                    "verification_obligations": [{"id": "VO-U01", "kind": "numerical"}],
+                }
+            }
+            (work / "design/units/U01.yaml").write_text(
+                yaml.safe_dump(unit), encoding="utf-8"
+            )
+            with (work / "operators/add/test/testcase.csv").open(
+                "w", encoding="utf-8", newline=""
+            ) as handle:
+                writer = csv.DictWriter(
+                    handle,
+                    fieldnames=[
+                        "sheet",
+                        "case_id",
+                        "unit_id",
+                        "status",
+                        "obligation_ids",
+                        "exclude_reason",
+                    ],
+                )
+                writer.writeheader()
+                writer.writerow(
+                    {
+                        "sheet": "tdd",
+                        "case_id": "TD-u01-main",
+                        "unit_id": "u01",
+                        "status": "active" if active else "excluded",
+                        "obligation_ids": "VO-U01",
+                        "exclude_reason": "" if active else "fixture exclusion",
+                    }
+                )
+                if excluded:
+                    writer.writerow(
+                        {
+                            "sheet": "tdd",
+                            "case_id": "TD-u01-excluded",
+                            "unit_id": "u01",
+                            "status": "excluded",
+                            "obligation_ids": "VO-U01",
+                            "exclude_reason": "fixture exclusion",
+                        }
+                    )
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    str(script),
+                    "--output-dir",
+                    str(work),
+                    "--harness-script",
+                    str(harness),
+                ],
+                capture_output=True,
+                text=True,
+            )
+            if not active:
+                self.assertNotEqual(result.returncode, 0)
+                self.assertFalse(
+                    (work / ".workflow/implementation-tasks.yaml").exists()
+                )
+                return
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertNotIn(
+                "TD-u01-excluded",
+                (work / ".workflow/implementation-tasks.yaml").read_text(),
+            )
+            graph = yaml.safe_load(
+                (work / ".workflow/implementation-tasks.yaml").read_text(
+                    encoding="utf-8"
+                )
+            )
+            implementation = graph["nodes"][0]
+            self.assertEqual(implementation["id"], "implement-u01")
+            self.assertIn("TD-u01-main", "\n".join(implementation["approach"]))
+            self.assertIn(
+                "design/units/U01.yaml", "\n".join(implementation["approach"])
+            )
+            self.assertNotIn("<op>", yaml.safe_dump(graph))
+            fix = next(
+                node for node in graph["nodes"] if node["id"] == "implementation-fix"
+            )
+            self.assertIn("implement-u01", fix["depends_on"])
+
+
+if __name__ == "__main__":
+    run_tests()

package/assets/ops-direct-invoke/skills/ops-direct-invoke-maintain/test/ut/support.py

@@ -0,0 +1,122 @@
+# ----------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------
+
+"""Shared fixtures for workflow public-interface tests; no harness internals imported."""
+import argparse
+import csv
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import yaml
+
+MAINTAIN_ROOT = Path(__file__).absolute().parents[2]
+SKILL_ROOT = MAINTAIN_ROOT.parent / 'ops-direct-invoke'
+SCRIPTS = SKILL_ROOT / 'scripts'
+WORKFLOWS = SKILL_ROOT / 'workflows'
+_installed_harness = MAINTAIN_ROOT.parent / 'workflow-orchestrator'
+HARNESS_SKILL = (_installed_harness if _installed_harness.exists()
+                 else SKILL_ROOT.resolve().parents[3] / 'harness/workflow-orchestrator')
+
+
+def task_fixture():
+    return {'task_type': 'normal', 'title': 'fixture', 'goal': ['produce a result'],
+            'approach': ['write result'], 'procedure': ['review result'],
+            'acceptance': ['result exists'], 'out_of_scope': ['unrelated work'],
+            'executor': 'ops-direct-invoke-developer', 'verifier': 'ops-direct-invoke-verifier',
+            'on_exhaust': 'exit'}
+
+
+class StrictLoader(yaml.SafeLoader):
+    """Do not let duplicate keys hide mistakes in committed YAML."""
+
+
+def strict_mapping(loader, node):
+    result = {}
+    for key_node, value_node in node.value:
+        key = loader.construct_object(key_node)
+        if not isinstance(key, str) or key in result:
+            raise ValueError(f'non-string or duplicate YAML key: {key!r}')
+        result[key] = loader.construct_object(value_node)
+    return result
+
+
+StrictLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, strict_mapping)
+
+
+def load_yaml(path):
+    loader = StrictLoader(path.read_text(encoding='utf-8'))
+    try:
+        return loader.get_single_data()
+    finally:
+        loader.dispose()
+
+
+def available_workflows():
+    with tempfile.TemporaryDirectory(prefix='workflow-guide-') as temp:
+        output = Path(temp) / 'workflow-guide.csv'
+        result = subprocess.run([sys.executable, str(SCRIPTS / 'generate_workflow_guide.py'),
+                                 '--output', str(output)], cwd=temp, capture_output=True, text=True, timeout=60)
+        if result.returncode:
+            raise ValueError(result.stdout + result.stderr)
+        with output.open(encoding='utf-8', newline='') as stream:
+            reader = csv.DictReader(stream, strict=True)
+            if reader.fieldnames != ['file', 'use_when']:
+                raise ValueError('guide requires file and use_when columns')
+            return list(reader)
+
+
+def run_command(case, arguments, cwd):
+    command = [sys.executable, *map(str, arguments)]
+    result = subprocess.run(command, cwd=cwd, capture_output=True, text=True, timeout=60)
+    case.assertEqual(result.returncode, 0,
+                     f'Command failed: {command}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}')
+    return result
+
+
+def generate_workflow(case, entry, directory):
+    arguments = [SCRIPTS / 'assemble_workflow.py', '--template', WORKFLOWS / entry['file'],
+                 '--output', directory / 'workflow.yaml']
+    run_command(case, arguments, directory)
+    return directory / 'workflow.yaml'
+
+
+def run_workflow(case, definition_flag, definition, work):
+    case.assertTrue((HARNESS_SKILL / 'scripts/orchestrator.py').is_file(),
+                    f'harness CLI missing: {HARNESS_SKILL}; pass --harness-skill')
+    source = WORKFLOWS / definition if definition_flag == '--template' else Path(definition)
+    graph = load_yaml(source)
+    for container in (node for node in graph['nodes'] if node.get('task_type') == 'subgraph'):
+        path = work / container['file']
+        path.parent.mkdir(parents=True, exist_ok=True)
+        child = {'id': 'fixture-unit', 'task_type': 'normal', 'title': 'dry-run fixture Unit',
+                 'goal': ['simulate one generated Unit'], 'approach': ['dry-run only'],
+                 'acceptance': ['dry-run pass'], 'out_of_scope': ['real operator work'],
+                 'depends_on': [], 'executor': 'ops-direct-invoke-developer',
+                 'verifier': 'ops-direct-invoke-verifier', 'max_retries': 0, 'on_exhaust': 'exit'}
+        path.write_text(yaml.safe_dump({'nodes': [child]}, allow_unicode=True), encoding='utf-8')
+    arguments = [SCRIPTS / 'run_workflow.py', definition_flag, definition,
+                 '--work-dir', work, '--provider', 'codex', '--prompt', 'registry UT simulation only',
+                 '--harness-skill', HARNESS_SKILL, '--foreground', '--dry-run']
+    # Deliberately launch outside the Skill directory to check resource path resolution.
+    run_command(case, arguments, work.parent)
+
+
+def run_tests():
+    """Every category exposes the same CLI, plus normal unittest options."""
+    import unittest
+    global HARNESS_SKILL
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--harness-skill', type=Path)
+    args, remaining = parser.parse_known_args()
+    if args.harness_skill:
+        HARNESS_SKILL = args.harness_skill.resolve()
+    unittest.main(argv=[sys.argv[0], *remaining], verbosity=2)

package/assets/ops-direct-invoke/skills/ops-direct-invoke-maintain/test/ut/test_all.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# ----------------------------------------------------------------------------
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+# ----------------------------------------------------------------------------
+
+"""Discover every UT category's test.py, run all, and fail if any category fails."""
+import argparse
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+LOGGER = logging.getLogger(__name__)
+
+
+def main():
+    logging.basicConfig(level=logging.INFO, format="%(message)s", stream=sys.stdout)
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--harness-skill', type=Path, help='override the shared harness Skill location')
+    args = parser.parse_args()
+    sys.dont_write_bytecode = True
+    root = Path(__file__).absolute().parent
+    categories = sorted(path for path in root.iterdir()
+                        if path.is_dir() and not path.name.startswith(('.', '_')))
+    if not categories:
+        LOGGER.error('No UT categories found.')
+        return 1
+    failed = []
+    for category in categories:
+        LOGGER.info('\n=== %s ===', category.name)
+        entry = category / 'test.py'
+        if not entry.is_file():
+            LOGGER.error('Missing required test entry: %s', entry)
+            failed.append(category.name)
+            continue
+        command = [sys.executable, '-B', str(entry)]
+        if args.harness_skill:
+            command.extend(['--harness-skill', str(args.harness_skill.resolve())])
+        try:
+            result = subprocess.run(command, cwd=root)
+            if result.returncode:
+                failed.append(category.name)
+        except OSError as error:
+            LOGGER.error('%s', error)
+            failed.append(category.name)
+    LOGGER.info('\nUT categories: %s passed, %s failed', len(categories) - len(failed), len(failed))
+    if failed:
+        LOGGER.error('Failed: %s', ', '.join(failed))
+    return 1 if failed else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())