ok-script 2.0.18__tar.gz → 2.0.20__tar.gz

{ok_script-2.0.18 → ok_script-2.0.20}/.agents/skills/develop/SKILL.md

@@ -11,7 +11,15 @@ Do not use Computer Use skills, plugins, or tools for this workflow, including t
 
 Read [docs/mcp.md](../../../docs/mcp.md) for the current server, tools, task contract, and artifacts. The coding agent already has local file and process access: write code and read logs/images directly. Use [setup-env](../setup-env/SKILL.md) or [setup-project](../setup-project/SKILL.md) only when setup is missing.
 
-For screenshot annotations and named template features, use [generate-templates](../generate-templates/SKILL.md): retain originals and COCO annotations in `ok_templates`, export individual PNGs with `generate_templates` into `assets/templates`, and verify `find_feature`/`find_one` using the original feature names. Existing packed COCO assets and `coco_feature_json` remain supported. The split loader reports malformed filenames; fix the indicated asset instead of lowering matching thresholds or ignoring the error.
+Before creating or changing named image features, read [generate-templates](../generate-templates/SKILL.md) and use the library's authoring/export pipeline:
+
+1. Retain full original screenshots in `ok_templates/` and record feature rectangles and names in `ok_templates/coco_annotations.json` using `CocoTemplateStore`.
+2. Call `ok.feature.FeatureSet.generate_templates` to export split PNGs into `assets/templates/` (or `ok_tasks/assets/templates/` for custom scripts). Let the exporter write the geometry-bearing filenames.
+3. Configure `template_matching.template_folder` and use `find_feature`/`find_one` with the original feature names in task code.
+
+Do not replace this pipeline with hand-cropped runtime PNGs, a custom template registry, or a parallel `cv2.matchTemplate` loader for named features. Crop previews are diagnostics, not runtime assets. Existing packed COCO assets and `coco_feature_json` remain supported. The split loader reports malformed filenames; fix the source annotation and regenerate instead of renaming crops or ignoring the error.
+
+The full screenshots in `ok_templates/` can also serve directly as regression-test fixtures. Follow [write-test](../write-test/SKILL.md) to exercise real task recognition with `TaskTestCase.set_image()` or the exported assets with `FeatureSet`; there is no need to duplicate these images under `tests/images/`. A source-image self-match checks the export path; add independent positive and negative screenshots when available to check recognition robustness.
 
 For existing registered tasks, prefer [reload-tasks](../reload-tasks/SKILL.md): discover their source with `list_tasks()`, edit it in place, call `reload_tasks(task_ids=[...])`, and wait for a successful reload before testing. Keep automation behavior in its existing module; use temporary MCP files only as thin validation harnesses. Create new task implementations when the requested functionality is new.
 

{ok_script-2.0.18 → ok_script-2.0.20}/.agents/skills/generate-templates/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: generate-templates
-description: Create template matching assets for a third-party ok-script application from its screenshots and COCO annotations, then verify them with find_feature or find_one.
+description: Create or change named image features using ok-script's ok_templates screenshots, COCO annotations, and split exporter; verify them with find_feature or find_one and reuse screenshots in tests.
 ---
 
 # Generate and use templates
@@ -15,6 +15,13 @@ split runtime assets. Keep source screenshots intact so both agents and the
 Template tab can inspect and reannotate them. The old compression APIs and dialog
 option are obsolete; use the split exporter for new or regenerated assets.
 
+For new named features, do not write standalone runtime crops into `assets/`,
+invent a template metadata format, or implement a separate `cv2.matchTemplate`
+registry/loader. Use `CocoTemplateStore` for authoring, `generate_templates` for
+runtime exports, and the library's named-feature matching APIs in tasks. A crop
+preview may be written outside the export folder for inspection, but it does not
+replace the source screenshot, COCO annotation, or generated split asset.
+
 Run from the automation project's root using its interpreter, following
 [use-venv](../use_venv/SKILL.md). For live capture and task execution follow
 [develop](../develop/SKILL.md), including reset, baseline verification, and
@@ -172,6 +179,15 @@ prove recognition is robust. Use the project's actual threshold, preprocessing,
 and anchor settings for representative verification. Keep evidence of what was
 tested and what remains unverified.
 
+Full screenshots in `ok_templates/` are also reusable offline test fixtures.
+Pass their paths directly to `TaskTestCase.set_image()` to test the application's
+real recognition methods, or load them as frames for `FeatureSet` tests using
+the generated runtime assets. Keep referenced screenshots with the project so
+tests remain reproducible; copying them to `tests/images/` is unnecessary.
+Retain independent positive/negative captures when available, and assert the
+expected state or match geometry rather than only checking that an image loads.
+Follow [write-test](../write-test/SKILL.md) for harness setup and isolation.
+
 In task code, use the existing methods:
 
 ```python

{ok_script-2.0.18 → ok_script-2.0.20}/.agents/skills/setup-env/SKILL.md

@@ -7,7 +7,7 @@ description: Install the ok-script Python package and create or repair a consumi
 
 Work in the consuming application's directory and use its configured environment or `.venv`. Inspect its requirements, lockfile, supported Python versions, and installed packages before changing dependencies. Installing and using ok-script does not require a library source checkout.
 
-Use this skill for requests such as "install ok-script and set up its environment", even before an MCP server exists. Read this file directly from the repository or installed package; starting MCP is not a prerequisite. After installation and verification, follow the project-creation handoff below.
+Use this skill for requests such as "install ok-script and set up its environment", even before an MCP server exists. Read this file directly from the repository or installed package; starting MCP is not a prerequisite. After installation and verification, generate the local development skill before the project-creation handoff below.
 
 ## Interpreter and dependencies
 
@@ -39,6 +39,34 @@ If the application already has a launcher, run it with its environment to catch
 
 Report the environment path, dependency profiles, OpenCV choice, and verification outcome.
 
+## Generate the project-local development skill
+
+After successful installation, create
+`<cwd>/.agents/skills/ok-script-develop/SKILL.md` in the consuming workspace where
+the user requested setup. This is part of agent setup, including installation-only
+requests; it does not depend on accepting project creation or starting MCP. When
+repairing an environment, add the skill if it is missing.
+
+Use [the generic development skill template](assets/ok-script-develop/SKILL.md)
+as the initial content. Prefer the template shipped with the selected installed
+release; locate this `setup-env` skill through `ok.core.skills.list_skills()` and
+resolve `assets/ok-script-develop/SKILL.md` from its parent directory. If the
+installed release predates the template, use the template accompanying these
+setup instructions without upgrading the dependency.
+
+Create the destination directory as needed and write the template as UTF-8. If
+the destination already exists, read it first and preserve its project-specific
+guidance; merge missing discovery instructions only when needed. Do not replace
+a customized skill with the generic template. Keep the template's generic name
+and description for new skills; do not copy game-specific observations, fixed
+machine paths, or unrelated application skills from another project.
+
+The generated skill discovers the library's version-matched instructions in place;
+do not copy the full consumer skill catalog into the application. Verify the
+generated file has its `name` and `description` frontmatter, and that its discovery
+instructions locate this environment's `develop/SKILL.md`. Report the generated
+or reused skill's path with the environment results.
+
 ## Offer to create a project
 
 After a successful initial installation, ask whether the user wants to create an automation project and which game or app it should target. For example: "ok-script is installed. Would you like to create an automation project now? If so, which game or app, and is it a Windows app or an Android device/emulator?" Wait for the answer before creating a project that has not already been requested.

ok_script-2.0.20/.agents/skills/setup-env/assets/ok-script-develop/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: ok-script-develop
+description: Develop and debug an application's automation with ok-script, including tasks, configuration, recognition assets, and tests. Discover the selected library's consumer skills and apply the project's conventions.
+---
+
+# Develop with ok-script
+
+Work in the consuming application's project and use its configured Python
+environment. This skill provides discovery and project integration for any game
+or app using ok-script; the selected library supplies the development workflow
+and API contracts. Library maintenance is outside this skill's scope.
+
+## Locate the library instructions
+
+Before changing automation behavior, locate the consumer skills matching the
+library this application actually uses:
+
+1. Check the project's local `ok` directory or configured source link. Resolve
+   symlinks and junctions. A source checkout keeps skills at
+   `<resolved-ok>/../.agents/skills`; a packaged directory keeps them at
+   `<resolved-ok>/agent_resources/.agents/skills`.
+2. If that source has no consumer skills, use the application's interpreter and
+   `importlib.metadata.distribution('ok-script').locate_file('ok')` to locate its
+   installed package, then check `agent_resources/.agents/skills` there. Do not
+   use another environment's global installation.
+3. Read `develop/SKILL.md` in the selected skill directory. Resolve its links
+   relative to that original file, including the MCP guide and input references.
+   Read `reload-tasks` for registered tasks, `generate-templates` for visual
+   assets, and `write-test` for tests. Read setup skills when environment or
+   runtime setup is needed.
+
+When available, the selected package's `core/skills.py` provides `list_skills()`
+and `get_skill()` with absolute source paths. Load that file with
+`runpy.run_path` to discover instructions without importing the GUI runtime.
+For example, with a local `ok` directory, run this using the project interpreter
+from the application root:
+
+```python
+from pathlib import Path
+import runpy
+
+catalog = runpy.run_path(str(Path('ok').resolve() / 'core' / 'skills.py'))
+for skill in catalog['list_skills']():
+    print(skill['id'], skill['path'])
+```
+
+Keep the library's detailed instructions in their original location so they
+follow its installed version. Inspect that version's source and signatures for
+API details. If no consumer skills are available, report the missing resources
+and use the project's setup guidance; do not invent MCP tools or silently upgrade
+the dependency just to obtain instructions.
+
+## Apply the workflow to this project
+
+Follow the selected library's development skill for MCP startup, connection
+discovery, task recovery, reloads, and runtime validation. Use ok-script APIs and
+MCP for target capture and interaction. Do not use Computer Use skills, plugins,
+or tools for this workflow.
+
+Inspect the project's instructions, config, launchers, existing tasks, and local
+skills before implementing changes. Reuse its task bases, registration style,
+recovery helpers, assets, and localization conventions. Keep behavior in permanent
+application modules and use thin MCP harnesses to exercise those implementations.
+
+For new or changed named image features, read the library's `generate-templates`
+skill before creating assets. Keep full screenshots in `ok_templates/`, annotate
+them in `ok_templates/coco_annotations.json` with `CocoTemplateStore`, and call
+`generate_templates` to produce split features in `assets/templates/` (or
+`ok_tasks/assets/templates/` for custom scripts). Use the original names through
+`find_feature`/`find_one`. Do not substitute hand-cropped runtime PNGs, a custom
+template registry, or a separate `cv2.matchTemplate` loader for this pipeline.
+
+The full images in `ok_templates/` can also be used directly as regression-test
+fixtures with `TaskTestCase.set_image()` or `FeatureSet`. Read the library's
+`write-test` skill, exercise real recognition with generated assets, and retain
+independent positive/negative screenshots when available. The source-image
+self-match alone verifies export consistency, not recognition robustness.
+
+Use the configured project environment even when it is shared from a parent
+workspace. Reuse this project's live runtime when suitable and follow the
+library's process ownership rules when a restart is required. Validate observable
+target behavior and relevant GUI lifecycle paths as described by the library.
+If the target is unavailable, continue useful code and offline checks and report
+the specific runtime checks that remain unverified.

{ok_script-2.0.18 → ok_script-2.0.20}/.agents/skills/setup-project/SKILL.md

@@ -43,6 +43,12 @@ workspace/
 
 Create supporting directories as needed. Reuse a matching existing project folder; if the current directory is already that project's folder, edit it in place rather than nesting another copy. Keep separate projects' config and launch scripts separate, even when they target the same app.
 
+Ensure each application's root has `.agents/skills/ok-script-develop/SKILL.md`,
+following the local skill generation instructions in [setup-env](../setup-env/SKILL.md).
+Do this even when its environment is shared with the parent workspace, so an agent
+opened directly in the application folder can discover development guidance.
+Preserve existing project-specific skill content.
+
 Projects may share the workspace environment just installed when their dependencies are compatible, or use a project-local environment when required. Record the chosen interpreter and use its absolute path in shortcuts and run instructions. Target launchers must work when invoked by absolute path from another working directory: resolve paths from `__file__`, make the project's task modules and config importable, and set the working directory to that project's subfolder before starting the runtime. Resolve mutable paths under that same folder so projects do not share settings, logs, or MCP ownership accidentally.
 
 Prefer the application's installed ok-script dependency. If the user explicitly requests a source link to an existing library installation, link `<project-root>\ok` to that checkout's `ok` directory and add the link's parent to `sys.path` before importing `ok`. Prefer a directory symbolic link; if Windows denies symlink privileges, use a directory junction. Verify existing destinations and resolved paths before replacing anything; never recursively delete through the link. This is dependency access, not permission to modify library code.

{ok_script-2.0.18 → ok_script-2.0.20}/.agents/skills/write-test/SKILL.md

@@ -27,7 +27,7 @@ Import `TaskTestCase` from `ok.test.TaskTestCase`; set class attributes `task_cl
 
 The current harness initializes one task per test class, replaces capture with `ImageCaptureMethod`, and uses `DoNothingInteraction`. `set_image(path)` advances the frame and checks template sizing; `set_images(*paths)` installs a sequence and advances its first frame. Read the capture implementation when testing frame progression rather than assuming repeated reads advance it.
 
-- Store reproducible screenshots under the target project's `tests/images/`, or reuse an existing tracked `ok_templates` source when appropriate. Confirm each fixture exists and loads.
+- Reuse full source screenshots in the target project's `ok_templates/` directly as test fixtures, including screenshots used to author COCO annotations and split features. Pass their paths to `set_image()`; no copy into `tests/images/` is required. Keep referenced images with the project and confirm they exist and load. Additional test-only captures may live under `tests/images/` or the project's existing fixture directory.
 - Load the image before calling the recognition method. Exercise real recognition rather than mocking the method being tested.
 - Assert the detected state, value, feature name, confidence, or box geometry as appropriate. Include an absent or negative case when it distinguishes the regression.
 - For scaling bugs, use representative resolutions and aspect ratios with `subTest`; preserve the intended center/right anchors and allow a justified pixel tolerance. Include positive matches and blank-frame negatives when relevant.
@@ -35,6 +35,15 @@ The current harness initializes one task per test class, replaces capture with `
 - Do not treat no-op input as proof that an in-game click worked. Test action intent with mocks; use the [develop skill](../develop/SKILL.md) when actual GUI/MCP interaction is part of the request.
 - For fixture annotation or named feature creation, follow [generate-templates](../generate-templates/SKILL.md).
 
+For example, in a `TaskTestCase` method, call
+`self.set_image(str(project_root / "ok_templates" / "settings-open.png"))`, then
+invoke the real task recognition method and assert its result. Resolve
+`project_root` from the test file or the project's existing test configuration.
+Use the generated `assets/templates` features through the real application
+config. Matching a feature against its own authoring screenshot verifies the
+annotation/export/load path; include independent positives and negatives when
+available to catch false matches and appearance changes.
+
 For direct split-template tests, construct `FeatureSet(False, None, 0.002, 0.002,
 template_folder=<absolute export folder>)`. For packed COCO tests, pass the JSON
 path as the second argument. Match using the original feature name, without the

{ok_script-2.0.18 → ok_script-2.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.18
+Version: 2.0.20
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 License: ok-script License
@@ -212,6 +212,8 @@ python -m venv .venv
 - [白荆回廊](https://github.com/ok-oldking/ok-baijing)（停止维护）
 - [明日方舟：终末地](https://github.com/AliceJump/ok-end-field)
 - [异环](https://github.com/BnanZ0/ok-nte)
+- [棕色尘埃 2](https://github.com/GodRaymond233/ok-bd2)
+- [蓝色星原：旅谣](https://github.com/longer-sausage/OK-AzurPromilia)
 
 ## 社区与发布
 

{ok_script-2.0.18 → ok_script-2.0.20}/README.md

@@ -85,6 +85,8 @@ python -m venv .venv
 - [白荆回廊](https://github.com/ok-oldking/ok-baijing)（停止维护）
 - [明日方舟：终末地](https://github.com/AliceJump/ok-end-field)
 - [异环](https://github.com/BnanZ0/ok-nte)
+- [棕色尘埃 2](https://github.com/GodRaymond233/ok-bd2)
+- [蓝色星原：旅谣](https://github.com/longer-sausage/OK-AzurPromilia)
 
 ## 社区与发布
 

{ok_script-2.0.18 → ok_script-2.0.20}/docs/agent-setup.md

@@ -21,14 +21,18 @@ When asked to install, configure, or repair ok-script or its Python environment,
 read https://raw.githubusercontent.com/ok-oldking/ok-script/master/docs/agent-setup.md
 and follow the relevant setup skills before changing the environment.
 Use this project's virtual environment and preserve its dependency constraints.
+After installation, generate .agents/skills/ok-script-develop/SKILL.md in the
+current workspace using the setup-env template, preserving any existing custom skill.
 After installation, offer to create an automation project and ask for missing
 game/app details. Give each project its own subfolder, config, and start scripts.
 ```
 
 Installing a Python package does not register its instructions with a coding
 agent. The prompt or project instruction supplies the discovery link; after
-installation, the package also provides local copies of the skills. No MCP
-server is needed to read the setup instructions.
+installation, the package also provides local copies of the skills. The coding
+agent then generates a discoverable development skill in the consuming workspace;
+`pip install` alone does not write project instructions. No MCP server is needed
+to read the setup instructions or generate this local skill.
 
 ## Instructions for the coding agent
 
@@ -49,26 +53,36 @@ server is needed to read the setup instructions.
    workflow. Select only the profiles the requested application needs; a desktop
    GUI commonly uses `default,qt`, with exactly one compatible OpenCV variant
    installed separately. Verify the environment before offering project creation.
-4. After a successful initial installation, ask: "Would you like to create an
+4. After installation, generate
+   `<cwd>/.agents/skills/ok-script-develop/SKILL.md` using the generic template
+   linked from `setup-env`. This step also applies to installation-only requests;
+   preserve and merge an existing customized skill rather than overwriting it.
+   Verify it can locate the selected library's consumer development instructions.
+   The skill applies to any consuming game or app and discovers the library's
+   instructions in place instead of duplicating them.
+5. After a successful initial installation, ask: "Would you like to create an
    automation project now? Which game or app should it automate, and is it a
    Windows app or an Android device/emulator?" If the user already requested a
    project, ask only for missing details. Skip this offer when repairing an
    existing project or when the user has explicitly declined project creation.
-5. When project creation is requested, read the
+6. When project creation is requested, read the
    [setup-project skill](https://github.com/ok-oldking/ok-script/blob/master/.agents/skills/setup-project/SKILL.md).
    Identify the actual executable/window or device/app from the user's answers
    and local inspection. Ask for any required details that remain ambiguous;
    wait for those answers before writing target-dependent config. Create each
    project in its own named workspace subfolder, containing its own `config.py`,
    `start_gui.py`, and `start_mcp.py`. Keep its tasks, assets, settings, and logs
-   in that folder too. Omit `gui_icon` to use the default `OK` PNG bundled with
+   in that folder too. Ensure its root also has the local `ok-script-develop`
+   skill, even if it shares the workspace environment. Omit `gui_icon` to use the
+   default `OK` PNG bundled with
    the Python package; set it only when supplying a custom application icon.
    Reuse an existing project in place. Projects may share
    the prepared environment when compatible. Use the installed version's APIs
    and verify that launchers work when invoked from outside their subfolder.
-6. Run the checks in the relevant skills. Report the environment path, installed
+7. Run the checks in the relevant skills. Report the environment path, installed
    ok-script version, dependency profiles, OpenCV choice, and verification
-   results. For application setup, also report the project folder, config,
+   results, plus the generated or reused development skill path. For application
+   setup, also report the project folder, config,
    launcher paths, and which target capture/input checks succeeded.
 
 ## Read skills from an installed package

{ok_script-2.0.18 → ok_script-2.0.20}/docs/feature-crops.md

@@ -14,6 +14,11 @@ Use Split for new exports. Existing COCO assets remain readable.
 Keep the original screenshots and COCO annotations in `ok_templates` for editing
 and future exports. Split exports require only the PNG files at runtime.
 
+Coding agents should use this same pipeline: author with `CocoTemplateStore`,
+export with `generate_templates`, and match named features with
+`find_feature`/`find_one`. Hand-cropped runtime PNGs and a custom OpenCV template
+loader bypass the library's annotation, scaling, and export workflow.
+
 ## Configuration
 
 Add `template_folder` alongside the existing configuration; all variance,
@@ -106,6 +111,14 @@ boxes = features.find_feature(frame, 'settings_save', threshold=0.95)
 assert len(boxes) == 1, boxes
 ```
 
+Full screenshots in `ok_templates` can also serve directly as regression-test
+fixtures. Pass a screenshot path to `TaskTestCase.set_image()` to exercise the
+application's real recognition methods, or load it for a `FeatureSet` test as
+above. Keep referenced screenshots with the project; no duplicate under
+`tests/images` is needed. A self-match on the authoring image verifies the export
+path. Add independent positive and negative screenshots when available to test
+recognition robustness, using the application's actual matching settings.
+
 Also verify representative screenshots at the supported resolutions. The GUI
 Save action reloads its feature set. After programmatic export, refresh cached
 features with `feature_set.process_data()` on the executor thread, or restart the

{ok_script-2.0.18 → ok_script-2.0.20}/docs/mcp.md

@@ -12,6 +12,13 @@ The agent writes and edits project files, starts the local runtime, and reads lo
 
 MCP supplies skills and task execution, not a Python API catalog or `get_api` tool. Use the application's interpreter and inspect its installed package for exact signatures, docstrings, inherited methods, and return behavior. No library checkout is needed. See [agent prompts](en/agent-prompts.md) for API-only discovery and existing-task repair examples.
 
+The server's connection instructions direct agents to `get_skill("generate-templates")`
+before creating named image features: keep full screenshots and COCO annotations
+in `ok_templates`, export split features with `generate_templates`, and use
+`find_feature`/`find_one` in tasks. Those full screenshots can also be used directly
+as regression-test fixtures; `get_skill("write-test")` describes the test workflow.
+These instructions and skills come from the server's installed ok-script version.
+
 ## Install and start
 
 If the project has no environment or MCP runtime yet, start with the

{ok_script-2.0.18 → ok_script-2.0.20}/ok/capture/adb/nemu_ipc.py

@@ -203,12 +203,13 @@ def retry(func):
 
 
 class NemuIpcImpl:
-    def __init__(self, nemu_folder: str, instance_id: int, display_id: int = 0):
+    def __init__(self, nemu_folder: str, instance_id: int, display_id: int = 0, runtime_version: str = '12.0'):
         """
         Args:
             nemu_folder: Installation path of MuMu12, e.g. E:/ProgramFiles/MuMuPlayer-12.0
             instance_id: Emulator instance ID, starting from 0
             display_id: Always 0 if keep app alive was disabled
+            runtime_version: Selected instance's runtime directory, such as 12.0 or 15.0
         """
         self.nemu_folder: str = nemu_folder
         self.instance_id: int = instance_id
@@ -218,8 +219,8 @@ class NemuIpcImpl:
         list_dll = [
             # MuMuPlayer12
             os.path.abspath(os.path.join(nemu_folder, './shell/sdk/external_renderer_ipc.dll')),
-            # MuMuPlayer12 5.0
-            os.path.abspath(os.path.join(nemu_folder, './nx_device/12.0/shell/sdk/external_renderer_ipc.dll')),
+            # MuMu's versioned runtime layout
+            os.path.abspath(os.path.join(nemu_folder, 'nx_device', runtime_version, 'shell/sdk/external_renderer_ipc.dll')),
         ]
         self.lib = None
         for ipc_dll in list_dll:
@@ -460,11 +461,12 @@ class NemuIpcImpl:
 class NemuIpc:
     _screenshot_interval = Timer(0.1)
 
-    def __init__(self, nemu_folder: str, instance_id: int, display_id: int = 0):
+    def __init__(self, nemu_folder: str, instance_id: int, display_id: int = 0, runtime_version: str = '12.0'):
         self.nemu_ipc = None
         self.nemu_folder = nemu_folder
         self.instance_id = instance_id
         self.display_id = display_id
+        self.runtime_version = runtime_version
         self.nemu_ipc = self.init_nemu_ipc()
 
     def init_nemu_ipc(self) -> NemuIpcImpl:
@@ -481,7 +483,8 @@ class NemuIpc:
             return NemuIpcImpl(
                 nemu_folder=self.nemu_folder,
                 instance_id=self.instance_id,
-                display_id=0
+                display_id=self.display_id,
+                runtime_version=self.runtime_version
             ).__enter__()
         except (NemuIpcIncompatible, NemuIpcError, JobTimeout) as e:
             logger.error('Unable to initialize NemuIpc', e)

{ok_script-2.0.18 → ok_script-2.0.20}/ok/core/mcp_server.py

@@ -113,6 +113,14 @@ def create_mcp_app(runner, token, port, request_exit=None):
         'with the relevant skill ID before working. Skills are also MCP resources. '
         'These skills are for the consuming application: its tasks, config, assets, '
         'environment and tests, not for developing or publishing the ok-script library. '
+        'Before creating or changing named image features, read get_skill("generate-templates"). '
+        'Keep full screenshots and coco_annotations.json in ok_templates, author with '
+        'CocoTemplateStore, and call generate_templates to export split features into '
+        'assets/templates (ok_tasks/assets/templates for custom scripts). Use find_feature '
+        'or find_one with original feature names; do not substitute hand-cropped runtime '
+        'PNGs or a custom cv2.matchTemplate loader. Full ok_templates screenshots can also '
+        'be used directly as regression-test fixtures with TaskTestCase.set_image or '
+        'FeatureSet; read get_skill("write-test") for testing. '
         'For existing tasks, prefer list_tasks, edit the returned source files in place, '
         'then reload_tasks with task_ids (omit task_ids to reload all). Poll get_run_status '
         'until the reload finishes before testing. Read the reload-tasks skill for this workflow. '

{ok_script-2.0.18 → ok_script-2.0.20}/ok/device/capture_methods/base.py

@@ -36,8 +36,8 @@ class BaseCaptureMethod:
         """Capture a frame.
 
         :param busy_wait: Seconds to wait when another caller owns the capture.
-            The default 0 returns None immediately, which suits polling loops
-            such as the task executor; one-off captures should wait instead.
+            The default 0 returns None immediately. The task executor waits
+            briefly; one-off captures should wait longer.
         """
         if self.exit_event.is_set():
             return

{ok_script-2.0.18 → ok_script-2.0.20}/ok/device/capture_methods/nemu_ipc.py

@@ -1,5 +1,6 @@
 import json
 import os
+import re
 
 from ok.util.collection import deep_get
 from ok.util.logger import Logger
@@ -10,7 +11,7 @@ logger = Logger.get_logger(__name__)
 
 class NemuIpcCaptureMethod(BaseCaptureMethod):
     name = "Nemu Ipc Capture"
-    description = "mumu player 12 only"
+    description = "MuMu Player native capture"
 
     def __init__(self, device_manager, exit_event, width=0, height=0):
         super().__init__()
@@ -34,16 +35,22 @@ class NemuIpcCaptureMethod(BaseCaptureMethod):
             self.nemu_impl = NemuIpc(
                 nemu_folder=self.base_folder(),
                 instance_id=self.emulator.player_id,
-                display_id=0
+                display_id=0,
+                runtime_version=self.runtime_version()
             )
 
     def base_folder(self):
         return os.path.dirname(os.path.dirname(self.emulator.path))
 
+    def runtime_version(self):
+        match = re.search(r'-(\d+(?:\.\d+)+)-\d+$', getattr(self.emulator, 'name', ''))
+        return match.group(1) if match else '12.0'
+
     def check_mumu_app_keep_alive_400(self):
+        instance_name = getattr(self.emulator, 'name', None) or f'MuMuPlayer-12.0-{self.emulator.player_id}'
         file = os.path.abspath(os.path.join(
             self.base_folder(),
-            f'vms/MuMuPlayer-12.0-{self.emulator.player_id}/configs/customer_config.json'))
+            'vms', instance_name, 'configs/customer_config.json'))
 
         try:
             with open(file, mode='r', encoding='utf-8') as f:

{ok_script-2.0.18 → ok_script-2.0.20}/ok/device/interaction_methods/keys.py

@@ -151,3 +151,33 @@ ADB_KEY_MAP = {
     'printscreen': 'KEYCODE_SYSRQ',
     'print_screen': 'KEYCODE_SYSRQ',
 }
+
+XBUTTON1 = 0x0001
+XBUTTON2 = 0x0002
+MOUSEEVENTF_XDOWN = 0x0080
+MOUSEEVENTF_XUP = 0x0100
+
+WM_XBUTTONDOWN = 0x020B
+WM_XBUTTONUP = 0x020C
+MK_XBUTTON1 = 0x0020
+MK_XBUTTON2 = 0x0040
+
+MOUSE_BUTTON_MAP = {
+    'mouse4': XBUTTON1,
+    'xbutton1': XBUTTON1,
+    'mouse5': XBUTTON2,
+    'xbutton2': XBUTTON2,
+}
+
+
+def is_mouse_button(key) -> bool:
+    if not isinstance(key, str):
+        return False
+    return key.strip().lower() in MOUSE_BUTTON_MAP
+
+
+def get_mouse_button(key) -> int:
+    if not isinstance(key, str):
+        return 0
+    return MOUSE_BUTTON_MAP.get(key.strip().lower(), 0)
+

{ok_script-2.0.18 → ok_script-2.0.20}/ok/device/interaction_methods/post_message.py

@@ -6,7 +6,10 @@ import win32gui
 
 from ok.device.capture_methods.base import BaseCaptureMethod
 from ok.device.interaction_methods.base import BaseInteraction
-from ok.device.interaction_methods.keys import vk_key_dict
+from ok.device.interaction_methods.keys import (
+    vk_key_dict, is_mouse_button, get_mouse_button,
+    XBUTTON1, MK_XBUTTON1, MK_XBUTTON2, WM_XBUTTONDOWN, WM_XBUTTONUP
+)
 from ok.util.logger import Logger
 
 logger = Logger.get_logger(__name__)
@@ -37,12 +40,27 @@ class PostMessageInteraction(BaseInteraction):
     def send_key_down(self, key, activate=True):
         if activate:
             self.try_activate()
+        if is_mouse_button(key):
+            btn = get_mouse_button(key)
+            mk = MK_XBUTTON1 if btn == XBUTTON1 else MK_XBUTTON2
+            wparam = win32api.MAKELONG(mk, btn)
+            pos = getattr(self, 'mouse_pos', (0, 0))
+            lparam = win32api.MAKELONG(int(pos[0]), int(pos[1]))
+            self.post(WM_XBUTTONDOWN, wparam, lparam)
+            return
         vk_code = self.get_key_by_str(key)
         lparam = self.make_lparam(vk_code, is_up=False)
         self.post(win32con.WM_KEYDOWN, vk_code, lparam)
 
     def send_key_up(self, key):
         # logger.debug(f'send_key_up {key}')
+        if is_mouse_button(key):
+            btn = get_mouse_button(key)
+            wparam = win32api.MAKELONG(0, btn)
+            pos = getattr(self, 'mouse_pos', (0, 0))
+            lparam = win32api.MAKELONG(int(pos[0]), int(pos[1]))
+            self.post(WM_XBUTTONUP, wparam, lparam)
+            return
         vk_code = self.get_key_by_str(key)
         lparam = self.make_lparam(vk_code, is_up=True)
         self.post(win32con.WM_KEYUP, vk_code, lparam)
@@ -215,6 +233,9 @@ class PostMessageInteraction(BaseInteraction):
             self._dynamic_target_hwnd = target_hwnd
 
             local_x, local_y = win32gui.ScreenToClient(target_hwnd, (abs_x, abs_y))
+            # Button messages must use the same target-client coordinates as
+            # the preceding move, including when a child window is selected.
+            self.mouse_pos = (local_x, local_y)
 
             hwnd_descriptions = []
             for index, hwnd_info in enumerate(hwnds):
@@ -233,7 +254,8 @@ class PostMessageInteraction(BaseInteraction):
         except Exception as e:
             logger.error(f'update_mouse_pos conversion error targeting {base_hwnd}', e)
             self._dynamic_target_hwnd = base_hwnd
-            return win32api.MAKELONG(int(x), int(y))
+            self.mouse_pos = (int(x), int(y))
+            return win32api.MAKELONG(*self.mouse_pos)
 
     def mouse_up(self, key="left"):
         if key == "left":