shortcuts-playground 1.2.1

package/skills/shortcuts-playground/scripts/test_random_mixed_shortcuts.py

@@ -0,0 +1,1067 @@
+#!/usr/bin/env python3
+"""Generate and validate random mixed-action shortcut stress tests.
+
+This harness builds brand-new shortcuts with randomized parameters and optional
+modules, enforces a minimum number of distinct actions per shortcut, validates
+them with retries, and writes documentation artifacts for auditability.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import os
+import plistlib
+import random
+import shutil
+import subprocess
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+from validate_shortcut import (
+    load_allowed_ids,
+    load_future_parameter_key_reasons,
+    load_future_toolkit_id_reasons,
+    load_icon_metadata,
+    load_toolkit_parameter_boolean_keys,
+    load_toolkit_parameter_enum_cases,
+    load_toolkit_parameter_schemas,
+    resolve_target_macos_major,
+    resolve_target_platform,
+    validate,
+)
+
+PLACEHOLDER = "\uFFFC"
+
+WEATHER_DETAILS = [
+    "Condition",
+    "Temperature",
+    "High",
+    "Low",
+    "Humidity",
+    "UV Index",
+    "Sunrise Time",
+    "Sunset Time",
+    "Wind Speed",
+    "Visibility",
+]
+
+ENDPOINTS = [
+    ("https://httpbin.org/get?case={i}", "url"),
+    ("https://api.agify.io?name=alex", "age"),
+    ("https://api.genderize.io?name=alex", "gender"),
+    ("https://catfact.ninja/fact", "fact"),
+    ("https://jsonplaceholder.typicode.com/todos/1", "title"),
+]
+
+EXTRA_MODULES = ("detect.link", "text.changecase", "base64")
+
+
+@dataclass
+class BuildResult:
+    workflow: dict[str, Any]
+    distinct_actions: int
+    action_ids: list[str]
+    extras_used: list[str]
+
+
+def seeded_uuid(seed: str) -> str:
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed)).upper()
+
+
+def action_output(output_uuid: str, output_name: str) -> dict[str, Any]:
+    return {
+        "WFSerializationType": "WFTextTokenAttachment",
+        "Value": {
+            "Type": "ActionOutput",
+            "OutputUUID": output_uuid,
+            "OutputName": output_name,
+        },
+    }
+
+
+def variable_wrapper_action_output(output_uuid: str, output_name: str) -> dict[str, Any]:
+    return {
+        "Type": "Variable",
+        "Variable": action_output(output_uuid, output_name),
+    }
+
+
+def token_string_action_output(output_uuid: str, output_name: str) -> dict[str, Any]:
+    return {
+        "WFSerializationType": "WFTextTokenString",
+        "Value": {
+            "string": PLACEHOLDER,
+            "attachmentsByRange": {
+                "{0, 1}": {
+                    "Type": "ActionOutput",
+                    "OutputUUID": output_uuid,
+                    "OutputName": output_name,
+                }
+            },
+        },
+    }
+
+
+def token_string_from_parts(parts: list[Any]) -> dict[str, Any]:
+    text = ""
+    attachments: dict[str, dict[str, Any]] = {}
+    for part in parts:
+        if isinstance(part, str):
+            text += part
+            continue
+        start = len(text)
+        text += PLACEHOLDER
+        attachments[f"{{{start}, 1}}"] = part
+    payload: dict[str, Any] = {"string": text}
+    if attachments:
+        payload["attachmentsByRange"] = attachments
+    return {"WFSerializationType": "WFTextTokenString", "Value": payload}
+
+
+def prompt_comment(case_name: str) -> str:
+    return (
+        "Shortcuts generated by Shortcuts Playground. May contain mistakes. "
+        "Always check the shortcut's actions first.\n\n"
+        "This shortcut was created via the following user prompt:\n\n"
+        f"> Random mixed-action stress test for {case_name}"
+    )
+
+
+def make_workflow(name: str, actions: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "WFWorkflowActions": actions,
+        "WFWorkflowClientVersion": "2700.0.4",
+        "WFWorkflowHasOutputFallback": False,
+        "WFWorkflowIcon": {
+            "WFWorkflowIconGlyphNumber": 61440,
+            "WFWorkflowIconStartColor": 431817727,
+        },
+        "WFWorkflowImportQuestions": [],
+        "WFWorkflowInputContentItemClasses": [],
+        "WFWorkflowMinimumClientVersion": 900,
+        "WFWorkflowMinimumClientVersionString": "900",
+        "WFWorkflowName": name,
+        "WFWorkflowOutputContentItemClasses": [],
+        "WFWorkflowTypes": [],
+    }
+
+
+def append_os27_actions(
+    actions: list[dict[str, Any]],
+    case_name: str,
+    idx: int,
+    uid,
+) -> list[str]:
+    extras_used = ["os27.actions"]
+
+    os27_text_uuid = uid("os27-text")
+    os27_key_uuid = uid("os27-key")
+    os27_list_uuid = uid("os27-list")
+    os27_added_uuid = uid("os27-add-item")
+    os27_stored_uuid = uid("os27-stored-get")
+    os27_group_uuid = uid("os27-otherwise-if-group")
+    os27_selected_uuid = uid("os27-selected-text")
+    os27_screen_uuid = uid("os27-on-screen")
+    os27_find_vpns_uuid = uid("os27-find-vpns")
+    os27_vpn_uuid = uid("os27-current-vpn")
+
+    conditional_input = variable_wrapper_action_output(os27_added_uuid, "List")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        "OS 27 module: Add Item to List, Stored Content, "
+                        "Otherwise If, selected text, on-screen context, and VPN."
+                    )
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_text_uuid,
+                    "WFTextActionText": f"{case_name} OS 27 stored value",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_key_uuid,
+                    "WFTextActionText": f"sp27-random-{idx:03d}",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setstoredcontent",
+                "WFWorkflowActionParameters": {
+                    "WFInput": token_string_action_output(os27_text_uuid, "Text"),
+                    "WFStoredContentKey": token_string_action_output(os27_key_uuid, "Text"),
+                    "WFStoredContentGlobalValue": False,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getstoredcontent",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_stored_uuid,
+                    "WFStoredContentKey": f"sp27-random-{idx:03d}",
+                    "WFStoredContentGlobalValue": False,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.deletestoredcontent",
+                "WFWorkflowActionParameters": {
+                    "WFStoredContentKey": f"sp27-random-{idx:03d}",
+                    "WFStoredContentGlobalValue": False,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.list",
+                "WFWorkflowActionParameters": {"UUID": os27_list_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.additemtolist",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_added_uuid,
+                    "WFListItem": "Apple",
+                    "WFListVariable": action_output(os27_list_uuid, "List"),
+                    "WFInsertPosition": "End",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        "- If checks the list created above for Apple\n"
+                        "- Otherwise If checks the same list for Orange"
+                    )
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.conditional",
+                "WFWorkflowActionParameters": {
+                    "GroupingIdentifier": os27_group_uuid,
+                    "WFControlFlowMode": 0,
+                    "WFCondition": 99,
+                    "WFInput": conditional_input,
+                    "WFConditionalActionString": "Apple",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.nothing",
+                "WFWorkflowActionParameters": {"UUID": uid("os27-if-apple-nothing")},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.conditional",
+                "WFWorkflowActionParameters": {
+                    "GroupingIdentifier": os27_group_uuid,
+                    "WFControlFlowMode": 1,
+                    "WFCondition": 99,
+                    "WFInput": conditional_input,
+                    "WFConditionalActionString": "Orange",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.nothing",
+                "WFWorkflowActionParameters": {"UUID": uid("os27-if-orange-nothing")},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.conditional",
+                "WFWorkflowActionParameters": {
+                    "GroupingIdentifier": os27_group_uuid,
+                    "WFControlFlowMode": 1,
+                    "WFInput": conditional_input,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.nothing",
+                "WFWorkflowActionParameters": {"UUID": uid("os27-if-else-nothing")},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.conditional",
+                "WFWorkflowActionParameters": {
+                    "GroupingIdentifier": os27_group_uuid,
+                    "WFControlFlowMode": 2,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getselectedtext",
+                "WFWorkflowActionParameters": {"UUID": os27_selected_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getonscreencontext",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_screen_uuid,
+                    "WFOnScreenContextScope": "Focused App Only",
+                    "WFOnScreenContextLimitEnabled": True,
+                    "WFOnScreenContextLimit": 3,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.vpns",
+                "WFWorkflowActionParameters": {
+                    "UUID": os27_find_vpns_uuid,
+                    "WFContentItemInputParameter": "Library",
+                    "WFContentItemSortProperty": "Server Address",
+                    "WFContentItemSortOrder": "A to Z",
+                    "WFContentItemLimitEnabled": True,
+                    "WFContentItemLimitNumber": 3,
+                    "WFCompoundType": "1",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.vpn.get",
+                "WFWorkflowActionParameters": {"UUID": os27_vpn_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.showresult",
+                "WFWorkflowActionParameters": {
+                    "Text": token_string_from_parts(
+                        [
+                            "OS 27 stored content: ",
+                            {
+                                "Type": "ActionOutput",
+                                "OutputUUID": os27_stored_uuid,
+                                "OutputName": "Stored Content",
+                            },
+                            " / selected: ",
+                            {
+                                "Type": "ActionOutput",
+                                "OutputUUID": os27_selected_uuid,
+                                "OutputName": "Selected Text",
+                            },
+                            " / screen: ",
+                            {
+                                "Type": "ActionOutput",
+                                "OutputUUID": os27_screen_uuid,
+                                "OutputName": "On Screen Content",
+                            },
+                            " / vpns: ",
+                            {
+                                "Type": "ActionOutput",
+                                "OutputUUID": os27_find_vpns_uuid,
+                                "OutputName": "VPNs",
+                            },
+                            " / current vpn: ",
+                            {
+                                "Type": "ActionOutput",
+                                "OutputUUID": os27_vpn_uuid,
+                                "OutputName": "VPN",
+                            },
+                        ]
+                    )
+                },
+            },
+        ]
+    )
+    return extras_used
+
+
+def build_case(
+    case_name: str,
+    idx: int,
+    rng: random.Random,
+    *,
+    include_os27_actions: bool = False,
+) -> BuildResult:
+    uid = lambda label: seeded_uuid(f"{case_name}-{label}")
+    actions: list[dict[str, Any]] = []
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        f"{case_name}: random mixed-action validation stress test case."
+                    )
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {"WFCommentActionText": prompt_comment(case_name)},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        "Section 1: Gather date, location, and weather data."
+                    )
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        "Section 2: Fetch web data and derive numeric values."
+                    )
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": (
+                        "Section 3: Rename output and present a final summary."
+                    )
+                },
+            },
+        ]
+    )
+
+    # Date + formatting
+    date_uuid = uid("date")
+    fmt_uuid = uid("format-date")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.date",
+            "WFWorkflowActionParameters": {"UUID": date_uuid, "WFDateActionMode": "Current Date"},
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.format.date",
+            "WFWorkflowActionParameters": {
+                "UUID": fmt_uuid,
+                "WFDate": token_string_action_output(date_uuid, "Date"),
+                "WFDateFormatStyle": "Custom",
+                "WFDateFormat": "Custom",
+                "WFDateFormatString": rng.choice(
+                    ["yyyy-MM-dd", "MMM d, yyyy", "yyyy-MM-dd HH:mm"]
+                ),
+            },
+        }
+    )
+
+    # Location + weather
+    loc_uuid = uid("current-location")
+    weather_uuid = uid("weather")
+    weather_detail_uuid = uid("weather-detail")
+    weather_var_uuid = uid("weather-var")
+    loc_var_uuid = uid("location-var")
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.getcurrentlocation",
+            "WFWorkflowActionParameters": {"UUID": loc_uuid},
+        }
+    )
+
+    use_location_var = rng.choice([True, False])
+    location_var_name = f"Location Ref {idx}"
+    location_output = action_output(loc_uuid, "Current Location")
+    if use_location_var:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "UUID": loc_var_uuid,
+                    "WFVariableName": location_var_name,
+                    "WFInput": location_output,
+                },
+            }
+        )
+
+    weather_ident = rng.choice(
+        [
+            "is.workflow.actions.weather.currentconditions",
+            "is.workflow.actions.weather.forecast",
+        ]
+    )
+    weather_params: dict[str, Any] = {
+        "UUID": weather_uuid,
+        # Keep weather location typed by wiring directly from Get Current Location.
+        "WFWeatherCustomLocation": location_output,
+    }
+    if weather_ident == "is.workflow.actions.weather.forecast":
+        weather_params["WFWeatherForecastType"] = rng.choice(["Hourly", "Daily"])
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": weather_ident,
+            "WFWorkflowActionParameters": weather_params,
+        }
+    )
+
+    use_weather_var = rng.choice([True, False])
+    weather_input: dict[str, Any]
+    if use_weather_var:
+        weather_var_name = f"Weather Data {idx}"
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "UUID": weather_var_uuid,
+                    "WFVariableName": weather_var_name,
+                    "WFInput": action_output(weather_uuid, "Weather Conditions"),
+                },
+            }
+        )
+    weather_input = action_output(weather_uuid, "Weather Conditions")
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.properties.weather.conditions",
+            "WFWorkflowActionParameters": {
+                "UUID": weather_detail_uuid,
+                "WFInput": weather_input,
+                "WFContentItemPropertyName": rng.choice(WEATHER_DETAILS),
+            },
+        }
+    )
+
+    # Explicit Location action (tests WFLocation wiring)
+    location_action_uuid = uid("location-action")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.location",
+            "WFWorkflowActionParameters": {
+                "UUID": location_action_uuid,
+                # Keep Location action typed by wiring directly from Get Current Location.
+                "WFLocation": location_output,
+            },
+        }
+    )
+
+    # Web data chain
+    url_uuid = uid("url")
+    dl_uuid = uid("download")
+    dict_uuid = uid("detect-dictionary")
+    key_uuid = uid("get-key")
+    split_uuid = uid("split")
+    count_uuid = uid("count")
+    endpoint, dict_key = rng.choice(ENDPOINTS)
+    endpoint = endpoint.format(i=idx)
+    separator = rng.choice(["/", ":", "?", "-"])
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.url",
+            "WFWorkflowActionParameters": {"UUID": url_uuid, "WFURLActionURL": endpoint},
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.downloadurl",
+            "WFWorkflowActionParameters": {
+                "UUID": dl_uuid,
+                "WFURL": token_string_action_output(url_uuid, "URL"),
+                "WFHTTPMethod": "GET",
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.detect.dictionary",
+            "WFWorkflowActionParameters": {
+                "UUID": dict_uuid,
+                "WFInput": action_output(dl_uuid, "Contents of URL"),
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.getvalueforkey",
+            "WFWorkflowActionParameters": {
+                "UUID": key_uuid,
+                "WFDictionaryKey": dict_key,
+                "WFInput": action_output(dict_uuid, "Dictionary"),
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.text.split",
+            "WFWorkflowActionParameters": {
+                "UUID": split_uuid,
+                "WFTextSeparator": "Custom",
+                "WFTextCustomSeparator": separator,
+                "text": token_string_action_output(key_uuid, "Dictionary Value"),
+            },
+        }
+    )
+    count_input = action_output(split_uuid, "Split Text")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.count",
+            "WFWorkflowActionParameters": {
+                "UUID": count_uuid,
+                "WFInput": count_input,
+                "Input": count_input,
+            },
+        }
+    )
+
+    # Numeric chain
+    num_uuid = uid("number")
+    math_uuid = uid("math")
+    round_uuid = uid("round")
+    math_op = rng.choice([None, "-", "×", "÷"])
+    math_operand = rng.randint(2, 9)
+    math_params: dict[str, Any] = {
+        "UUID": math_uuid,
+        "WFMathOperand": str(math_operand),
+        "WFInput": action_output(num_uuid, "Number"),
+    }
+    if math_op is not None:
+        math_params["WFMathOperation"] = math_op
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.number",
+            "WFWorkflowActionParameters": {"UUID": num_uuid, "WFNumberActionNumber": rng.randint(1, 30)},
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.math",
+            "WFWorkflowActionParameters": math_params,
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.round",
+            "WFWorkflowActionParameters": {
+                "UUID": round_uuid,
+                "WFRoundMode": "Normal",
+                "WFInput": action_output(math_uuid, "Calculation Result"),
+            },
+        }
+    )
+
+    # Set Name action
+    rename_uuid = uid("set-name")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.setitemname",
+            "WFWorkflowActionParameters": {
+                "UUID": rename_uuid,
+                "WFInput": action_output(key_uuid, "Dictionary Value"),
+                "WFName": f"Test-{idx:03d}.txt",
+            },
+        }
+    )
+
+    # Optional random extras
+    extras_used: list[str] = []
+    extra_count = rng.randint(0, 2)
+    for module in rng.sample(EXTRA_MODULES, extra_count):
+        if module == "detect.link":
+            extras_used.append(module)
+            actions.append(
+                {
+                    "WFWorkflowActionIdentifier": "is.workflow.actions.detect.link",
+                    "WFWorkflowActionParameters": {
+                        "UUID": uid(f"detect-link-{len(extras_used)}"),
+                        "WFInput": token_string_action_output(key_uuid, "Dictionary Value"),
+                    },
+                }
+            )
+        elif module == "text.changecase":
+            extras_used.append(module)
+            actions.append(
+                {
+                    "WFWorkflowActionIdentifier": "is.workflow.actions.text.changecase",
+                    "WFWorkflowActionParameters": {
+                        "UUID": uid(f"change-case-{len(extras_used)}"),
+                        "WFCaseType": rng.choice(["UPPERCASE", "lowercase", "Capitalize Every Word"]),
+                        "text": token_string_action_output(key_uuid, "Dictionary Value"),
+                    },
+                }
+            )
+        elif module == "base64":
+            extras_used.append(module)
+            actions.append(
+                {
+                    "WFWorkflowActionIdentifier": "is.workflow.actions.base64encode",
+                    "WFWorkflowActionParameters": {
+                        "UUID": uid(f"base64-{len(extras_used)}"),
+                        "WFEncodeMode": "Encode",
+                        "WFBase64LineBreakMode": "None",
+                        "WFInput": action_output(key_uuid, "Dictionary Value"),
+                    },
+                }
+            )
+
+    if include_os27_actions:
+        extras_used.extend(append_os27_actions(actions, case_name, idx, uid))
+
+    # Final summary
+    summary_uuid = uid("summary")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+            "WFWorkflowActionParameters": {
+                "UUID": summary_uuid,
+                "WFTextActionText": token_string_from_parts(
+                    [
+                        f"Case {idx}: date ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": fmt_uuid,
+                            "OutputName": "Formatted Date",
+                        },
+                        ", weather ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": weather_detail_uuid,
+                            "OutputName": "Details of Weather Conditions",
+                        },
+                        ", key ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": key_uuid,
+                            "OutputName": "Dictionary Value",
+                        },
+                        ", count ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": count_uuid,
+                            "OutputName": "Count",
+                        },
+                        ", math ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": round_uuid,
+                            "OutputName": "Rounded Number",
+                        },
+                        ", renamed ",
+                        {
+                            "Type": "ActionOutput",
+                            "OutputUUID": rename_uuid,
+                            "OutputName": "Renamed File",
+                        },
+                        ".",
+                    ]
+                ),
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.showresult",
+            "WFWorkflowActionParameters": {"Text": token_string_action_output(summary_uuid, "Text")},
+        }
+    )
+
+    workflow = make_workflow(case_name, actions)
+    action_ids = [
+        action.get("WFWorkflowActionIdentifier")
+        for action in actions
+        if action.get("WFWorkflowActionIdentifier") != "is.workflow.actions.comment"
+    ]
+    distinct_actions = len(set(action_ids))
+    return BuildResult(
+        workflow=workflow,
+        distinct_actions=distinct_actions,
+        action_ids=action_ids,
+        extras_used=extras_used,
+    )
+
+
+def write_shortcut(path: Path, workflow: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(plistlib.dumps(workflow, fmt=plistlib.FMT_XML, sort_keys=False))
+
+
+def _run_shortcuts_sign(input_path: Path, output_path: Path) -> tuple[int, str]:
+    proc = subprocess.run(
+        [
+            "shortcuts",
+            "sign",
+            "--mode",
+            "anyone",
+            "--input",
+            str(input_path),
+            "--output",
+            str(output_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    output = (proc.stdout or "").strip() + ("\n" + proc.stderr.strip() if proc.stderr else "")
+    return proc.returncode, output.strip()
+
+
+def sign_shortcut(path: Path) -> tuple[int, str]:
+    # Apple's signer can reject hidden dotfile inputs with a misleading
+    # "not in the correct format" error, so keep temporary shortcut names visible.
+    tmp_input = path.with_name(f"{path.stem}-sign-input-{os.getpid()}.shortcut")
+    tmp_output = path.with_name(f"{path.stem}-sign-output-{os.getpid()}.shortcut")
+    try:
+        shutil.copy2(path, tmp_input)
+        rc, output = _run_shortcuts_sign(tmp_input, tmp_output)
+        if rc == 0:
+            shutil.move(str(tmp_output), path)
+            return 0, output
+
+        first_output = output
+        shutil.copy2(path, tmp_input)
+        tmp_output.unlink(missing_ok=True)
+        lint = subprocess.run(["plutil", "-lint", str(tmp_input)], capture_output=True, text=True)
+        if lint.returncode != 0:
+            lint_output = (lint.stdout or "").strip() + (
+                "\n" + lint.stderr.strip() if lint.stderr else ""
+            )
+            return rc, "\n".join(part for part in (first_output, lint_output.strip()) if part)
+
+        convert = subprocess.run(
+            ["plutil", "-convert", "binary1", str(tmp_input)],
+            capture_output=True,
+            text=True,
+        )
+        if convert.returncode != 0:
+            convert_output = (convert.stdout or "").strip() + (
+                "\n" + convert.stderr.strip() if convert.stderr else ""
+            )
+            return rc, "\n".join(part for part in (first_output, convert_output.strip()) if part)
+
+        rc_binary, output_binary = _run_shortcuts_sign(tmp_input, tmp_output)
+        if rc_binary == 0:
+            shutil.move(str(tmp_output), path)
+            return 0, "\n".join(
+                part
+                for part in (
+                    first_output,
+                    "Retried after binary plist conversion.",
+                    output_binary,
+                )
+                if part
+            )
+        return rc_binary, "\n".join(part for part in (first_output, output_binary) if part)
+    finally:
+        tmp_input.unlink(missing_ok=True)
+        tmp_output.unlink(missing_ok=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate random mixed-action shortcut matrix and validate with retries."
+    )
+    parser.add_argument("--count", type=int, default=50, help="Number of shortcuts to generate")
+    parser.add_argument("--min-actions", type=int, default=10, help="Minimum distinct actions per shortcut")
+    parser.add_argument("--seed", type=int, default=260224, help="Base RNG seed")
+    parser.add_argument("--max-attempts", type=int, default=20, help="Generation retries per shortcut")
+    parser.add_argument("--output-dir", help="Override output directory")
+    parser.add_argument("--sign", action="store_true", help="Sign generated shortcuts after validation")
+    parser.add_argument(
+        "--target-macos",
+        default="auto",
+        help="Validation target macOS major: auto, latest, 26, or 27",
+    )
+    parser.add_argument(
+        "--target-platform",
+        default="macos",
+        help="Validation target platform: macos, ios, ipad, iphone, or all",
+    )
+    parser.add_argument(
+        "--include-os27-actions",
+        action="store_true",
+        help="Include an explicit OS 27 action module in every generated shortcut",
+    )
+    args = parser.parse_args()
+    target_macos_major = resolve_target_macos_major(args.target_macos)
+    target_platform = resolve_target_platform(args.target_platform)
+    if args.include_os27_actions and target_macos_major not in (27, None):
+        parser.error("--include-os27-actions requires --target-macos 27 or latest")
+
+    runid = dt.datetime.now().strftime("%H%M%S")
+    date_folder = dt.datetime.now().strftime("%Y-%m-%d")
+    configured_output_dir = (
+        args.output_dir
+        or os.environ.get("SHORTCUTS_PLAYGROUND_OUTPUT_DIR")
+        or os.environ.get("CLAUDE_PLUGIN_OPTION_OUTPUT_DIR")
+        or str(Path.home() / "Documents" / "Shortcuts Playground")
+    )
+    out_dir = (
+        Path(configured_output_dir).expanduser().resolve()
+        / date_folder
+        / f"random-mixed-actions-{runid}"
+    )
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    skill_dir = Path(__file__).resolve().parents[1]
+    allowed_ids = load_allowed_ids(skill_dir, target_macos_major, target_platform)
+    allowed_glyph_ids, allowed_icon_colors = load_icon_metadata(skill_dir)
+    unavailable_ids = load_future_toolkit_id_reasons(
+        skill_dir,
+        target_macos_major,
+        target_platform,
+    )
+    unavailable_parameter_keys = load_future_parameter_key_reasons(target_macos_major)
+    toolkit_parameter_schemas = load_toolkit_parameter_schemas(
+        skill_dir,
+        target_macos_major,
+        target_platform,
+    )
+    toolkit_parameter_enum_cases = load_toolkit_parameter_enum_cases(
+        skill_dir,
+        target_macos_major,
+        target_platform,
+    )
+    toolkit_parameter_boolean_keys = load_toolkit_parameter_boolean_keys(
+        skill_dir,
+        target_macos_major,
+        target_platform,
+    )
+
+    results: list[dict[str, Any]] = []
+    manifest: list[dict[str, Any]] = []
+    action_coverage: dict[str, int] = {}
+    distinct_counts: list[int] = []
+    failed_cases = 0
+
+    for idx in range(1, args.count + 1):
+        case_prefix = "ZZ-RAND27" if args.include_os27_actions else "ZZ-RAND26"
+        case_name = f"{case_prefix}-{runid}-{idx:03d}"
+        case_path = out_dir / f"{case_name}.shortcut"
+        case_record: dict[str, Any] = {
+            "index": idx,
+            "name": case_name,
+            "path": str(case_path),
+            "attempts": [],
+            "status": "failed",
+        }
+
+        passed: Optional[BuildResult] = None
+        for attempt in range(1, args.max_attempts + 1):
+            rng = random.Random(args.seed + idx * 1000 + attempt)
+            built = build_case(
+                case_name,
+                idx,
+                rng,
+                include_os27_actions=args.include_os27_actions,
+            )
+
+            if built.distinct_actions < args.min_actions:
+                case_record["attempts"].append(
+                    {
+                        "attempt": attempt,
+                        "distinct_actions": built.distinct_actions,
+                        "valid": False,
+                        "errors": [f"distinct action count below {args.min_actions}"],
+                        "extras_used": built.extras_used,
+                    }
+                )
+                continue
+
+            errors, _ = validate(
+                built.workflow,
+                allowed_ids,
+                allowed_glyph_ids,
+                allowed_icon_colors,
+                unavailable_ids=unavailable_ids,
+                unavailable_parameter_keys=unavailable_parameter_keys,
+                toolkit_parameter_schemas=toolkit_parameter_schemas,
+                toolkit_parameter_enum_cases=toolkit_parameter_enum_cases,
+                toolkit_parameter_boolean_keys=toolkit_parameter_boolean_keys,
+            )
+            case_record["attempts"].append(
+                {
+                    "attempt": attempt,
+                    "distinct_actions": built.distinct_actions,
+                    "valid": len(errors) == 0,
+                    "errors": errors[:20],
+                    "extras_used": built.extras_used,
+                }
+            )
+            if not errors:
+                passed = built
+                break
+
+        if passed is None:
+            failed_cases += 1
+            results.append(case_record)
+            continue
+
+        write_shortcut(case_path, passed.workflow)
+        sign_info: dict[str, Any] = {"skipped": True}
+        if args.sign:
+            rc, output = sign_shortcut(case_path)
+            sign_info = {"skipped": False, "rc": rc, "output_tail": output[-1200:]}
+            if rc != 0:
+                case_record["status"] = "failed-sign"
+                case_record["sign"] = sign_info
+                results.append(case_record)
+                failed_cases += 1
+                continue
+
+        distinct_counts.append(passed.distinct_actions)
+        for ident in set(passed.action_ids):
+            action_coverage[ident] = action_coverage.get(ident, 0) + 1
+
+        manifest.append(
+            {
+                "name": case_name,
+                "path": str(case_path),
+                "distinct_actions": passed.distinct_actions,
+                "action_ids": passed.action_ids,
+                "extras_used": passed.extras_used,
+            }
+        )
+        case_record["status"] = "passed"
+        case_record["distinct_actions"] = passed.distinct_actions
+        case_record["extras_used"] = passed.extras_used
+        case_record["sign"] = sign_info
+        results.append(case_record)
+
+    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    (out_dir / "results.json").write_text(json.dumps(results, indent=2), encoding="utf-8")
+
+    passed_cases = len([r for r in results if r.get("status") == "passed"])
+    total_attempts = sum(len(r.get("attempts", [])) for r in results)
+    retried_cases = len([r for r in results if len(r.get("attempts", [])) > 1])
+
+    summary_lines = [
+        f"# Random Mixed Action Stress Test ({runid})",
+        "",
+        f"- Date: {dt.datetime.now().isoformat(timespec='seconds')}",
+        f"- Requested cases: {args.count}",
+        f"- Passed cases: {passed_cases}",
+        f"- Failed cases: {failed_cases}",
+        f"- Minimum distinct actions target: {args.min_actions}",
+        f"- Target macOS: {args.target_macos}",
+        f"- Target platform: {args.target_platform}",
+        f"- OS 27 action module: {'enabled' if args.include_os27_actions else 'disabled'}",
+        f"- Total generation attempts: {total_attempts}",
+        f"- Cases requiring retries: {retried_cases}",
+    ]
+
+    if distinct_counts:
+        summary_lines.extend(
+            [
+                f"- Distinct actions per passed shortcut (min/max): {min(distinct_counts)}/{max(distinct_counts)}",
+                f"- Distinct actions average: {sum(distinct_counts) / len(distinct_counts):.2f}",
+            ]
+        )
+
+    summary_lines.extend(["", "## Action Coverage (passed cases)"])
+    for ident in sorted(action_coverage):
+        summary_lines.append(f"- {ident}: {action_coverage[ident]}")
+
+    summary_lines.extend(
+        [
+            "",
+            "## Artifacts",
+            f"- manifest.json: {out_dir / 'manifest.json'}",
+            f"- results.json: {out_dir / 'results.json'}",
+        ]
+    )
+
+    (out_dir / "summary.md").write_text("\n".join(summary_lines) + "\n", encoding="utf-8")
+
+    print(f"OUT_DIR={out_dir}")
+    print(
+        f"TOTAL={args.count} PASSED={passed_cases} FAILED={failed_cases} "
+        f"RETRIED={retried_cases} ATTEMPTS={total_attempts}"
+    )
+    if distinct_counts:
+        print(
+            f"DISTINCT_ACTIONS_MIN={min(distinct_counts)} "
+            f"DISTINCT_ACTIONS_MAX={max(distinct_counts)}"
+        )
+    return 0 if failed_cases == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())