@1aboveio/skills 1.0.17 → 1.0.18

package/skills/app-dev/android-development/scripts/test_maestro_failure.py

@@ -1,461 +1,150 @@
-"""Focused tests for maestro_failure.py: fixture Maestro output, no device, no Maestro.
+"""Thin forwarding coverage for the Android ``maestro_failure`` compatibility entry point.
 
-The fixtures are the artifact layout Maestro's docs describe for a Flow folder
-(manifest.json, commands.json, screenshots/, screen-hierarchy/, logs/), with the
-commands.json entry shape taken from Maestro's source (TestOutputWriter and
-CommandDebugMetadata) because the docs name the fields but show no example.
+The converter and its full suite now live in the sibling ``maestro`` skill
+(``skills/fullstack/maestro/scripts``). These tests only prove that the old Android path
+still reaches that converter and still shares its record model, including when both skill
+folders are copied into a staged package.
 
 Run directly (`python3 test_maestro_failure.py`) or through
-`scripts/maestro-failure.test.mjs`, which is what CI discovers.
+`maestro-failure.test.mjs`, which is what CI discovers.
 """
 
-import contextlib
-import io
 import json
 import os
+import shutil
+import subprocess
 import sys
 import tempfile
 import unittest
 
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from failure_capture import NATIVE_FAILURE_PREFIX, RECORD_KEYS, RECORD_NAME, read_record  # noqa: E402
-from maestro_failure import (  # noqa: E402
-    MaestroOutputError,
-    convert,
-    describe_command,
-    error_text,
-    main,
-)
-
-SESSION = "2026-07-31_173617"
-FLOW = "checkout_flow"
-CASE = "checkout smoke"
-
-LAUNCHED = {
-    "command": {"launchAppCommand": {"appId": "com.example.app", "optional": False}},
-    "metadata": {
-        "status": "COMPLETED",
-        "timestamp": 1700000000000,
-        "duration": 1200,
-        "sequenceNumber": 0,
-        "depth": 0,
-    },
-}
-
-TAPPED = {
-    "command": {
-        "tapOnElement": {
-            "selector": {"text": "Pay", "optional": False},
-            "label": "Tap Pay",
-            "optional": False,
-        }
-    },
-    "metadata": {
-        "status": "COMPLETED",
-        "timestamp": 1700000001300,
-        "duration": 300,
-        "sequenceNumber": 1,
-        "depth": 0,
-    },
-}
-
-FAILED_RECEIPT = {
-    "command": {
-        "assertConditionCommand": {
-            "condition": {"visible": {"text": "Thank you", "optional": False}},
-            "optional": False,
-        }
-    },
-    "metadata": {
-        "status": "FAILED",
-        "timestamp": 1700000001700,
-        "duration": 30000,
-        "sequenceNumber": 2,
-        "depth": 0,
-        "error": {
-            "message": 'Assertion is false: "Thank you" is visible',
-            "debugMessage": "Screen hierarchy has no match",
-        },
-        "artifacts": [
-            {"type": "SCREEN_HIERARCHY", "path": "screen-hierarchy/step-003-assertCondition.json"},
-            {"type": "SCREENSHOT", "path": "screenshots/step-003-assertCondition.png"},
-        ],
-    },
-}
+HERE = os.path.dirname(os.path.abspath(__file__))
+FORWARDER = os.path.join(HERE, "maestro_failure.py")
+MAESTRO_SCRIPTS = os.path.normpath(os.path.join(HERE, "..", "..", "maestro", "scripts"))
+
+
+def run_python(arguments, cwd):
+    """Run a Python command with no inherited PYTHONPATH, so imports come from `arguments`."""
+    environment = {key: value for key, value in os.environ.items() if key != "PYTHONPATH"}
+    return subprocess.run(
+        [sys.executable, *arguments],
+        cwd=cwd,
+        env=environment,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+
+def write_failing_flow(root):
+    """A Flow folder whose only step failed, with no artifacts beside it."""
+    flow_dir = os.path.join(root, "session", "checkout_flow")
+    os.makedirs(flow_dir)
+    with open(os.path.join(flow_dir, "commands.json"), "w", encoding="utf-8") as stream:
+        json.dump(
+            [
+                {
+                    "command": {"tapOnElement": {"selector": {"text": "Pay"}, "label": "Tap Pay"}},
+                    "metadata": {
+                        "status": "FAILED",
+                        "timestamp": 1700000000000,
+                        "sequenceNumber": 0,
+                        "error": {"message": "Element not found: Pay"},
+                    },
+                }
+            ],
+            stream,
+        )
+    return flow_dir
 
 
-class MaestroOutputCase(unittest.TestCase):
+class ForwarderCase(unittest.TestCase):
     def setUp(self):
         self.directory = tempfile.TemporaryDirectory()
         self.root = self.directory.name
-        self.output = io.StringIO()
+        self.elsewhere = os.path.join(self.root, "elsewhere")
+        os.makedirs(self.elsewhere)
 
     def tearDown(self):
         self.directory.cleanup()
 
-    def write(self, relative, payload):
-        path = os.path.join(self.root, relative)
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-        if isinstance(payload, bytes):
-            with open(path, "wb") as stream:
-                stream.write(payload)
-        else:
-            with open(path, "w", encoding="utf-8") as stream:
-                stream.write(payload)
-        return path
-
-    def write_json(self, relative, payload):
-        return self.write(relative, json.dumps(payload, indent=2))
-
-    def flow(self, steps, name=FLOW, session=SESSION, artifacts=None, manifest=True):
-        """A Flow folder with `steps` in commands.json and the optional artifact files."""
-        base = os.path.join(session, name) if session else name
-        self.write_json(os.path.join(base, "commands.json"), steps)
-        if manifest:
-            self.write_json(
-                os.path.join(base, "manifest.json"),
-                {
-                    "$schema": "https://storage.googleapis.com/maestro-schemas/artifact-manifest/v1.schema.json",
-                    "entries": [
-                        {"kind": "COMMAND_METADATA", "format": "JSON", "relativePath": "commands.json"}
-                    ],
-                },
-            )
-        for relative, payload in (artifacts or {}).items():
-            self.write(os.path.join(base, relative), payload)
-        return os.path.join(self.root, base)
-
-    def failing_flow(self, name=FLOW, session=SESSION):
-        """The worked example: a launch and tap that passed, then a failed assertion."""
-        return self.flow(
-            [LAUNCHED, TAPPED, FAILED_RECEIPT],
-            name=name,
-            session=session,
-            artifacts={
-                "screenshots/step-003-assertCondition.png": b"\x89PNG\r\n\x1a\n",
-                "screen-hierarchy/step-003-assertCondition.json": '{"attributes": {"text": "Pay now"}}',
-                "logs/device-logcat.txt": "07-31 E ActivityManager: no match\n",
-            },
-        )
-
-    def run_convert(self, maestro_dir, **options):
-        options.setdefault("stream", self.output)
-        return convert(maestro_dir, **options)
-
-    def cli(self, *argv):
-        """Run main() and keep its stderr out of the test output."""
-        with contextlib.redirect_stderr(io.StringIO()):
-            return main(list(argv))
-
     def record(self, evidence_dir):
-        path = os.path.join(evidence_dir, RECORD_NAME)
-        self.assertTrue(os.path.isfile(path), path)
-        with open(path, encoding="utf-8") as stream:
+        with open(os.path.join(evidence_dir, "failure.json"), encoding="utf-8") as stream:
             return json.load(stream)
 
-    def lines(self):
-        return [line for line in self.output.getvalue().splitlines() if line]
-
-
-class FailingFlowTest(MaestroOutputCase):
-    def test_the_failing_step_becomes_the_record_and_the_line(self):
-        flow_dir = self.failing_flow()
-        failure = self.run_convert(flow_dir)
-
-        self.assertIsNotNone(failure)
-        record = self.record(flow_dir)
-        self.assertEqual(list(record), list(RECORD_KEYS))
-        self.assertEqual(record["case"], FLOW)
-        self.assertEqual(record["step"], 'Assert condition "Thank you"')
-        self.assertEqual(
-            record["error"],
-            'Assertion is false: "Thank you" is visible: Screen hierarchy has no match',
-        )
-        self.assertEqual(record["screenshot"], "screenshots/step-003-assertCondition.png")
-        self.assertEqual(record["uiDump"], "screen-hierarchy/step-003-assertCondition.json")
-        self.assertEqual(record["logcatTail"], "logs/device-logcat.txt")
-        self.assertEqual(record["evidenceDir"], flow_dir)
-        self.assertEqual(record["cleanupErrors"], [])
-        for name in (record["screenshot"], record["uiDump"], record["logcatTail"]):
-            self.assertTrue(os.path.isfile(os.path.join(flow_dir, name)), name)
-
-        lines = self.lines()
-        self.assertEqual(len(lines), 1)
-        self.assertTrue(lines[0].startswith(NATIVE_FAILURE_PREFIX))
-        self.assertEqual(
-            json.loads(lines[0][len(NATIVE_FAILURE_PREFIX) :]),
-            {
-                "case": FLOW,
-                "step": 'Assert condition "Thank you"',
-                "error": record["error"],
-                "evidenceDir": flow_dir,
-            },
-        )
-
-    def test_an_explicit_case_name_is_used(self):
-        flow_dir = self.failing_flow()
-        self.run_convert(flow_dir, case=CASE)
-        self.assertEqual(self.record(flow_dir)["case"], CASE)
-
-    def test_a_labelled_step_uses_the_label(self):
-        labelled = json.loads(json.dumps(FAILED_RECEIPT))
-        labelled["command"] = {
-            "tapOnElement": {
-                "selector": {"text": "Pay", "optional": False},
-                "label": "Tap Pay",
-                "optional": False,
-            }
-        }
-        flow_dir = self.flow([TAPPED, labelled])
-        self.run_convert(flow_dir)
-        self.assertEqual(self.record(flow_dir)["step"], "Tap Pay")
-
-    def test_the_failing_step_wins_over_a_later_one(self):
-        later = json.loads(json.dumps(FAILED_RECEIPT))
-        later["metadata"]["timestamp"] = 1700000009000
-        later["metadata"]["sequenceNumber"] = 3
-        later["metadata"]["error"] = {"message": "second failure"}
-        later["metadata"]["artifacts"] = [
-            {"type": "SCREENSHOT", "path": "screenshots/step-004-tapOnElement.png"}
-        ]
-        flow_dir = self.flow(
-            [TAPPED, FAILED_RECEIPT, later],
-            artifacts={"screenshots/step-003-assertCondition.png": b"png"},
-        )
-        self.run_convert(flow_dir)
-
-        record = self.record(flow_dir)
-        self.assertEqual(record["step"], 'Assert condition "Thank you"')
-        self.assertIn("Assertion is false", record["error"])
-        self.assertEqual(record["screenshot"], "screenshots/step-003-assertCondition.png")
-
-
-class PassingFlowTest(MaestroOutputCase):
-    def test_a_passing_flow_writes_nothing(self):
-        flow_dir = self.flow(
-            [LAUNCHED, TAPPED],
-            artifacts={"logs/device-logcat.txt": "07-31 I ActivityManager: clean\n"},
-        )
-        self.assertIsNone(self.run_convert(flow_dir))
-        self.assertFalse(os.path.exists(os.path.join(flow_dir, RECORD_NAME)))
-        self.assertEqual(self.output.getvalue(), "")
-
-    def test_a_flow_with_no_steps_writes_nothing(self):
-        flow_dir = self.flow([])
-        self.assertIsNone(self.run_convert(flow_dir))
-        self.assertEqual(self.output.getvalue(), "")
-
-    def test_a_folder_without_commands_json_is_not_converted(self):
-        self.write(os.path.join(SESSION, FLOW, "manifest.json"), "{}")
-        with self.assertRaises(MaestroOutputError):
-            self.run_convert(os.path.join(self.root, SESSION))
-        self.assertEqual(self.cli("--maestro-dir", os.path.join(self.root, SESSION)), 2)
-
-    def test_a_missing_folder_is_a_usage_error(self):
-        self.assertEqual(self.cli("--maestro-dir", os.path.join(self.root, "absent")), 2)
-
-
-class ExistingRecordTest(MaestroOutputCase):
-    def test_an_existing_record_is_kept_and_its_line_is_printed(self):
-        flow_dir = self.failing_flow()
-        kept = {
-            "case": CASE,
-            "step": "tap Pay",
-            "error": "RuntimeError: earlier failure",
-            "screenshot": None,
-            "uiDump": None,
-            "logcatTail": None,
-            "evidenceDir": flow_dir,
-            "cleanupErrors": [],
-        }
-        path = self.write_json(os.path.join(SESSION, FLOW, RECORD_NAME), kept)
-
-        failure = self.run_convert(flow_dir)
 
-        self.assertEqual(failure.case, CASE)
-        self.assertEqual(self.record(flow_dir), kept)
-        with open(path, encoding="utf-8") as stream:
-            self.assertIn("earlier failure", stream.read())
-        self.assertEqual(self.lines(), [failure.native_failure_line()])
+class ForwarderTest(ForwarderCase):
+    def test_the_old_command_line_still_converts(self):
+        flow_dir = write_failing_flow(self.root)
 
-    def test_a_record_already_in_an_override_evidence_dir_is_kept(self):
-        flow_dir = self.failing_flow()
-        evidence_dir = os.path.join(self.root, "run-evidence")
-        kept = {"case": CASE, "step": None, "error": "RuntimeError: earlier failure", "cleanupErrors": []}
-        self.write_json(os.path.join("run-evidence", RECORD_NAME), kept)
-
-        self.run_convert(flow_dir, evidence_dir=evidence_dir)
-
-        self.assertEqual(self.record(evidence_dir)["error"], "RuntimeError: earlier failure")
-        # The first failure owns the folder, so no Maestro artifact was copied into it.
-        self.assertFalse(os.path.exists(os.path.join(evidence_dir, "screenshots")))
-
-
-class MissingOptionalFilesTest(MaestroOutputCase):
-    def test_absent_artifacts_are_null_and_noted_without_losing_the_error(self):
-        flow_dir = self.flow([TAPPED, FAILED_RECEIPT], manifest=False)
-        self.run_convert(flow_dir)
-
-        record = self.record(flow_dir)
-        self.assertIsNone(record["screenshot"])
-        self.assertIsNone(record["uiDump"])
-        self.assertIsNone(record["logcatTail"])
-        self.assertEqual(record["step"], 'Assert condition "Thank you"')
-        self.assertIn("Assertion is false", record["error"])
-        self.assertEqual(len(record["cleanupErrors"]), 3)
-        self.assertTrue(record["cleanupErrors"][0].startswith("screenshot: "))
-        self.assertTrue(record["cleanupErrors"][1].startswith("uiDump: "))
-        self.assertTrue(record["cleanupErrors"][2].startswith("logcatTail: "))
-
-    def test_the_error_survives_a_listed_artifact_that_is_not_on_disk(self):
-        broken = json.loads(json.dumps(FAILED_RECEIPT))
-        broken["metadata"]["artifacts"] = [
-            {"type": "SCREENSHOT", "path": "screenshots/step-003-assertCondition.png"}
-        ]
-        flow_dir = self.flow([broken], artifacts={"logs/device-logcat.txt": "log\n"})
-        self.run_convert(flow_dir)
-
-        record = self.record(flow_dir)
-        self.assertIsNone(record["screenshot"])
-        self.assertEqual(record["logcatTail"], "logs/device-logcat.txt")
-        self.assertIn(
-            "screenshots/step-003-assertCondition.png is not in the Maestro output",
-            " ".join(record["cleanupErrors"]),
+        result = run_python(
+            [FORWARDER, "--maestro-dir", flow_dir, "--case", "checkout"], cwd=self.elsewhere
         )
-        self.assertIn("Assertion is false", record["error"])
-
-    def test_an_unreadable_commands_json_is_not_silently_a_pass(self):
-        flow_dir = self.flow([FAILED_RECEIPT])
-        self.write(os.path.join(SESSION, FLOW, "commands.json"), "{not json")
-        with self.assertRaises(MaestroOutputError):
-            self.run_convert(flow_dir)
-
-
-class SessionFolderTest(MaestroOutputCase):
-    def test_the_session_folder_finds_the_failing_flow(self):
-        self.flow([LAUNCHED, TAPPED], name="login_flow")
-        failing_flow = self.failing_flow()
-        session_dir = os.path.join(self.root, SESSION)
-
-        failure = self.run_convert(session_dir)
-
-        self.assertEqual(failure.evidenceDir, failing_flow)
-        self.assertEqual(self.record(failing_flow)["case"], FLOW)
-
-    def test_the_earliest_failing_step_decides(self):
-        earlier = json.loads(json.dumps(FAILED_RECEIPT))
-        earlier["metadata"]["timestamp"] = 1700000000500
-        earlier["metadata"]["error"] = {"message": "earlier failure"}
-        earlier_dir = self.flow([LAUNCHED, earlier], name="login_flow")
-        later_dir = self.failing_flow(name="checkout_flow")
-
-        self.run_convert(os.path.join(self.root, SESSION))
-
-        self.assertEqual(self.record(earlier_dir)["error"], "earlier failure")
-        self.assertFalse(os.path.exists(os.path.join(later_dir, RECORD_NAME)))
-
-    def test_the_output_root_above_the_session_folder_works(self):
-        failing_flow = self.failing_flow()
-        self.run_convert(self.root)
-        self.assertTrue(os.path.isfile(os.path.join(failing_flow, RECORD_NAME)))
-
-
-class EvidenceDirTest(MaestroOutputCase):
-    def test_an_override_evidence_dir_holds_copies_and_relative_names(self):
-        flow_dir = self.failing_flow()
-        evidence_dir = os.path.join(self.root, "run-evidence")
-
-        failure = self.run_convert(flow_dir, evidence_dir=evidence_dir)
-
-        record = self.record(evidence_dir)
-        self.assertEqual(record["evidenceDir"], evidence_dir)
-        self.assertEqual(failure.evidenceDir, evidence_dir)
-        self.assertEqual(record["screenshot"], "screenshots/step-003-assertCondition.png")
-        self.assertEqual(record["uiDump"], "screen-hierarchy/step-003-assertCondition.json")
-        self.assertEqual(record["logcatTail"], "logs/device-logcat.txt")
-        for name in (record["screenshot"], record["uiDump"], record["logcatTail"]):
-            self.assertTrue(os.path.isfile(os.path.join(evidence_dir, name)), name)
-
-
-class DocumentedShapeTest(MaestroOutputCase):
-    def test_the_documented_flat_entry_shape_is_accepted(self):
-        flow_dir = self.flow(
-            [
-                {"command": "launchApp", "status": "COMPLETED", "duration": 1200, "sequenceNumber": 0},
-                {
-                    "command": "tapOn: Pay",
-                    "status": "FAILED",
-                    "duration": 300,
-                    "sequenceNumber": 1,
-                    "error": "Element not found: Pay",
-                    "artifacts": ["screenshots/step-002-tapOn.png"],
-                },
-            ],
-            artifacts={
-                "screenshots/step-002-tapOn.png": b"png",
-                "logs/device-logcat.txt": "log\n",
-            },
-        )
-
-        self.run_convert(flow_dir)
 
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len([line for line in result.stdout.splitlines() if line]), 1)
         record = self.record(flow_dir)
-        self.assertEqual(record["step"], "tapOn: Pay")
+        self.assertEqual(record["case"], "checkout")
+        self.assertEqual(record["step"], "Tap Pay")
         self.assertEqual(record["error"], "Element not found: Pay")
-        self.assertEqual(record["screenshot"], "screenshots/step-002-tapOn.png")
-        self.assertEqual(record["uiDump"], None)
-
-    def test_a_step_named_screenshot_is_found_without_an_artifacts_list(self):
-        unlisted = json.loads(json.dumps(FAILED_RECEIPT))
-        del unlisted["metadata"]["artifacts"]
-        unlisted["metadata"]["sequenceNumber"] = 1
-        flow_dir = self.flow(
-            [unlisted],
-            artifacts={
-                "screenshots/step-002-assertCondition.png": b"png",
-                "screen-hierarchy/step-002-assertCondition.json": "{}",
-                "logs/device-logcat.txt": "log\n",
-            },
-        )
 
-        self.run_convert(flow_dir)
-
-        record = self.record(flow_dir)
-        self.assertEqual(record["screenshot"], "screenshots/step-002-assertCondition.png")
-        self.assertEqual(record["uiDump"], "screen-hierarchy/step-002-assertCondition.json")
-
-    def test_an_ios_device_log_is_used_when_there_is_no_logcat(self):
-        flow_dir = self.flow(
-            [FAILED_RECEIPT],
-            artifacts={"logs/device-simulator.log": "simulator log\n"},
+    def test_the_old_import_api_returns_the_shared_record_model(self):
+        flow_dir = write_failing_flow(self.root)
+        out = os.path.join(self.elsewhere, "line.txt")
+        program = (
+            "import sys\n"
+            "sys.path.insert(0, sys.argv[1])\n"
+            "import maestro_failure\n"
+            "with open(sys.argv[3], 'w', encoding='utf-8') as stream:\n"
+            "    failure = maestro_failure.convert(sys.argv[2], stream=stream)\n"
+            "print(type(failure).__module__)\n"
         )
-        self.run_convert(flow_dir)
-        self.assertEqual(self.record(flow_dir)["logcatTail"], "logs/device-simulator.log")
 
+        result = run_python(["-c", program, HERE, flow_dir, out], cwd=self.elsewhere)
 
-class ReadingTest(unittest.TestCase):
-    def test_a_command_without_a_label_reads_as_its_type_and_target(self):
-        self.assertEqual(describe_command({"scrollCommand": {"optional": False}}), "Scroll")
-        self.assertEqual(
-            describe_command({"launchAppCommand": {"appId": "com.example.app"}}),
-            'Launch app "com.example.app"',
-        )
-        self.assertEqual(describe_command("tapOn: Pay"), "tapOn: Pay")
-        self.assertIsNone(describe_command(None))
-
-    def test_error_text_keeps_the_debug_detail(self):
-        self.assertEqual(error_text({"error": "boom"}), "boom")
-        self.assertEqual(
-            error_text({"error": {"message": "boom", "debugMessage": "screen has no Foo"}}),
-            "boom: screen has no Foo",
-        )
-        self.assertEqual(error_text({"error": {"message": "boom"}}), "boom")
-        self.assertEqual(error_text({}), "Maestro marked the step FAILED and gave no error message")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "failure_record")
+        self.assertEqual(self.record(flow_dir)["step"], "Tap Pay")
+        with open(out, encoding="utf-8") as stream:
+            self.assertTrue(stream.read().startswith("NATIVE_FAILURE "))
+
+
+class StagedSiblingLayoutTest(ForwarderCase):
+    """Both skill folders copied into a staged package, with no repository beside them."""
+
+    def copy_scripts(self, staged, skill, source):
+        scripts = os.path.join(staged, "skills", skill, "scripts")
+        os.makedirs(scripts)
+        for name in sorted(os.listdir(source)):
+            if name.endswith((".py", ".mjs")):
+                shutil.copyfile(os.path.join(source, name), os.path.join(scripts, name))
+        return scripts
+
+    def test_a_copied_pair_still_forwards_and_shares_the_record_model(self):
+        flow_dir = write_failing_flow(self.root)
+        with tempfile.TemporaryDirectory() as staged:
+            android_scripts = self.copy_scripts(staged, "android-development", HERE)
+            self.copy_scripts(staged, "maestro", MAESTRO_SCRIPTS)
+            work = os.path.join(staged, "work")
+            os.makedirs(work)
+
+            result = run_python(
+                [os.path.join(android_scripts, "maestro_failure.py"), "--maestro-dir", flow_dir],
+                cwd=work,
+            )
+            program = (
+                "import sys\n"
+                "sys.path.insert(0, sys.argv[1])\n"
+                "import failure_capture, failure_record\n"
+                "assert failure_capture.Failure is failure_record.Failure\n"
+                "assert failure_capture.read_record is failure_record.read_record\n"
+                "print(failure_capture.RECORD_NAME)\n"
+            )
+            model = run_python(["-c", program, android_scripts], cwd=work)
 
-    def test_read_record_ignores_a_non_record(self):
-        with tempfile.TemporaryDirectory() as directory:
-            self.assertIsNone(read_record(directory))
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(self.record(flow_dir)["step"], "Tap Pay")
+        self.assertEqual(model.returncode, 0, model.stderr)
+        self.assertEqual(model.stdout.strip(), "failure.json")
 
 
 if __name__ == "__main__":

package/skills/app-dev/app-debug/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: app-debug
 description: "Diagnose runtime failures in deployed Cloud Run services — 5xx/422 errors, tracebacks, Next.js SSR/hydration or Server Action failures, DB/Secret Manager connection errors, cold-start timeouts, container OOM. NOT for build or deploy failures (cloud-debug)."
-release-version: 0.48.1
+release-version: 0.49.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # App Debug

package/skills/app-dev/better-auth/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: better-auth
 description: "Add or debug Better Auth for Next.js App Router: login, sessions, protected routes, middleware, OAuth (including Feishu/Lark), cookies, Prisma, and Auth.js migration."
-release-version: 0.48.1
+release-version: 0.49.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Better Auth for Next.js

package/skills/app-dev/data-catalog/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: data-catalog
 description: "Column definitions for warehouse tables, written inside the Spark/PySpark or SQL script that builds each table (CATALOG_TABLE / CATALOG_FIELDS, or a `-- @field` comment block), with a generated markdown catalog in docs/catalog/ and a CI check that fails a PR whose catalog is stale. Use when writing or changing a table script that adds, renames, removes, or changes the meaning of an output column or feature; when asked what a warehouse column or feature means; to set a repo up ('init the data catalog', 'generate the data dictionary', '字段字典', 'add catalog CI'); or to audit existing SQL or Spark scripts for undocumented columns. NOT for implementing or tuning the Spark job itself (pyspark), DAG wiring (airflow), or general workflow YAML (github-actions)."
-release-version: 0.48.1
+release-version: 0.49.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Data catalog

package/skills/app-dev/data-quality/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: data-quality
 description: "Check a published warehouse table's data against its data-catalog definitions with read-only SELECTs: columns never filled or stuck at one value, counts below zero, ratios outside 0–1, declared values that never appear and undeclared values that do. Then classify each finding as a wrong definition, wrong code, or wrong data. Use when asked whether a table's data is right, to profile or sanity-check a dwd/ads table, to find dead or constant columns, to check a column's values against its documented list, after a pipeline change ships, or when a data-catalog definition and the data might disagree. NOT for validating a Spark change before it ships (pyspark canary and reconciliation), writing definitions (data-catalog), or monitoring dashboards."
-release-version: 0.48.1
+release-version: 0.49.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # Data quality

package/skills/app-dev/ios-foundation/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: ios-foundation
 description: "Set up and prove an Expo / React Native native iOS workspace from an assigned or fresh isolated workspace to a manual Login smoke on an owned iOS Simulator: isolated workspace and private caches, Xcode/runtime/CocoaPods preflight, frozen install with `pod install --deployment`, platform-scoped prebuild, an ad-hoc-signed Debug simulator build, a private simulator by exact UDID, Metro on a free port, a disposable PostgreSQL backend with owned cleanup, and the evidence record (setup proof only; feature work reports the smoke result). Use for 'set up iOS', 'build the iOS app', 'run the app on the iOS simulator', 'add iOS to the React Native app', 'prove the iOS build', or when a pod install, xcodebuild, simulator boot, Metro connection or Keychain session fails. NOT for Android (android-development), signing, TestFlight or App Store release, or general workflow YAML (github-actions)."
-release-version: 0.48.1
+release-version: 0.49.0
 ---
 **Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
 # iOS foundation

package/skills/app-dev/maestro/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 1AboveIO