keep-npu 1.0.0__tar.gz

keep_npu-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wang Siyuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

keep_npu-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+prune tests
+recursive-include docs *.md

keep_npu-1.0.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: keep-npu
+Version: 1.0.0
+Summary: KeepNPU is a polite NPU keeper with CLI, service, and MCP interfaces
+Author: Peter Zheng
+Maintainer: Peter Zheng
+License-Expression: MIT
+Project-URL: bugs, https://github.com/pzheng460/keep-npu/issues
+Project-URL: changelog, https://github.com/pzheng460/keep-npu/releases
+Project-URL: homepage, https://github.com/pzheng460/keep-npu
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: rich>=13.8.0
+Provides-Extra: dev
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Requires-Dist: setuptools<82,>=77; extra == "dev"
+Provides-Extra: ascend
+Dynamic: license-file
+
+# KeepNPU
+
+KeepNPU is a small, polite Huawei Ascend NPU keeper for shared machines. It
+matches KeepGPU's CLI, service, REST/JSON-RPC, MCP, and dashboard workflows,
+using `torch_npu` and `npu-smi` for Ascend devices.
+
+It allocates only when utilization backoff permits, keeps the requested device
+memory signal lightweight, and releases cleanly on exit.
+
+## Requirements
+
+- Python 3.9–3.13
+- Huawei Ascend driver and CANN runtime
+- A mutually compatible PyTorch and `torch_npu` installation
+
+Load the CANN environment before using KeepNPU when your system does not do so
+automatically:
+
+```console
+source /usr/local/Ascend/ascend-toolkit/latest/bin/setenv.bash
+```
+
+## Install
+
+```console
+python -m pip install keep-npu
+```
+
+`torch` and `torch_npu` are deliberately not installed as package dependencies:
+their versions must match the server's CANN and driver stack.
+
+To install the latest unreleased revision directly from GitHub:
+
+```console
+python -m pip install 'keep-npu @ git+https://github.com/pzheng460/keep-npu.git'
+```
+
+## Blocking mode
+
+Keep all visible NPUs, or select torch-visible ordinals with `--npu-ids`:
+
+```console
+keep-npu --vram 1GiB --interval 60
+keep-npu --npu-ids 0,2 --vram 512MiB --interval 30
+```
+
+Press `Ctrl+C` to release memory. The default utilization threshold is 25%;
+KeepNPU backs off while a device is busier than that or telemetry is unknown.
+Use `--busy-threshold -1` only when you intentionally want to disable backoff.
+
+## Service and dashboard
+
+Run the local HTTP service in the foreground:
+
+```console
+keep-npu serve --host 127.0.0.1 --port 8765
+```
+
+Open `http://127.0.0.1:8765/` for the dashboard. Non-blocking CLI workflows use
+the same service and auto-start it on localhost by default:
+
+```console
+keep-npu list-npus
+keep-npu start --npu-ids 0 --vram 1GiB --interval 60
+keep-npu status
+keep-npu stop --job-id JOB_ID
+keep-npu stop --all
+keep-npu service-stop
+```
+
+The service exposes `GET /health`, `GET /api/npus`, and session CRUD under
+`/api/sessions`. JSON-RPC is available at the exact `/rpc` endpoint, including
+MCP-shaped `tools/list` and `tools/call` messages. As in KeepGPU 1.0, HTTP mode
+is not a Streamable HTTP MCP endpoint; standards-based MCP transport is stdio.
+
+## MCP server
+
+For a local MCP client using stdio:
+
+```console
+keep-npu-mcp-server --mode stdio
+```
+
+For HTTP transport:
+
+```console
+keep-npu-mcp-server --mode http --host 127.0.0.1 --port 8765
+```
+
+The MCP tools are `start_keep`, `stop_keep`, `status`, and `list_npus`.
+
+## Ascend device semantics
+
+`--npu-ids` always addresses the visible ordinal used by `torch.npu`, after
+`ASCEND_RT_VISIBLE_DEVICES` filtering. `list-npus` additionally reports the
+physical ID when it can be derived safely. Memory comes from `torch.npu` with
+best-effort `npu-smi` telemetry; unavailable values are returned as `null`
+instead of being guessed.
+
+See [KeepGPU compatibility](https://github.com/pzheng460/keep-npu/blob/main/docs/compatibility.md)
+for the exact public-name mapping and intentional Ascend differences.
+
+## Development
+
+```console
+python -m pip install -e '.[dev]'
+PYTHONPATH=src python -m pytest
+cd web/dashboard && npm ci && npm test -- --run && npm run build
+```
+
+Hardware tests use the `ascend` pytest marker and conservative memory sizes.
+The original standalone `keep_npu_alive.py` entry point remains available for
+backward compatibility.

keep_npu-1.0.0/README.md

@@ -0,0 +1,113 @@
+# KeepNPU
+
+KeepNPU is a small, polite Huawei Ascend NPU keeper for shared machines. It
+matches KeepGPU's CLI, service, REST/JSON-RPC, MCP, and dashboard workflows,
+using `torch_npu` and `npu-smi` for Ascend devices.
+
+It allocates only when utilization backoff permits, keeps the requested device
+memory signal lightweight, and releases cleanly on exit.
+
+## Requirements
+
+- Python 3.9–3.13
+- Huawei Ascend driver and CANN runtime
+- A mutually compatible PyTorch and `torch_npu` installation
+
+Load the CANN environment before using KeepNPU when your system does not do so
+automatically:
+
+```console
+source /usr/local/Ascend/ascend-toolkit/latest/bin/setenv.bash
+```
+
+## Install
+
+```console
+python -m pip install keep-npu
+```
+
+`torch` and `torch_npu` are deliberately not installed as package dependencies:
+their versions must match the server's CANN and driver stack.
+
+To install the latest unreleased revision directly from GitHub:
+
+```console
+python -m pip install 'keep-npu @ git+https://github.com/pzheng460/keep-npu.git'
+```
+
+## Blocking mode
+
+Keep all visible NPUs, or select torch-visible ordinals with `--npu-ids`:
+
+```console
+keep-npu --vram 1GiB --interval 60
+keep-npu --npu-ids 0,2 --vram 512MiB --interval 30
+```
+
+Press `Ctrl+C` to release memory. The default utilization threshold is 25%;
+KeepNPU backs off while a device is busier than that or telemetry is unknown.
+Use `--busy-threshold -1` only when you intentionally want to disable backoff.
+
+## Service and dashboard
+
+Run the local HTTP service in the foreground:
+
+```console
+keep-npu serve --host 127.0.0.1 --port 8765
+```
+
+Open `http://127.0.0.1:8765/` for the dashboard. Non-blocking CLI workflows use
+the same service and auto-start it on localhost by default:
+
+```console
+keep-npu list-npus
+keep-npu start --npu-ids 0 --vram 1GiB --interval 60
+keep-npu status
+keep-npu stop --job-id JOB_ID
+keep-npu stop --all
+keep-npu service-stop
+```
+
+The service exposes `GET /health`, `GET /api/npus`, and session CRUD under
+`/api/sessions`. JSON-RPC is available at the exact `/rpc` endpoint, including
+MCP-shaped `tools/list` and `tools/call` messages. As in KeepGPU 1.0, HTTP mode
+is not a Streamable HTTP MCP endpoint; standards-based MCP transport is stdio.
+
+## MCP server
+
+For a local MCP client using stdio:
+
+```console
+keep-npu-mcp-server --mode stdio
+```
+
+For HTTP transport:
+
+```console
+keep-npu-mcp-server --mode http --host 127.0.0.1 --port 8765
+```
+
+The MCP tools are `start_keep`, `stop_keep`, `status`, and `list_npus`.
+
+## Ascend device semantics
+
+`--npu-ids` always addresses the visible ordinal used by `torch.npu`, after
+`ASCEND_RT_VISIBLE_DEVICES` filtering. `list-npus` additionally reports the
+physical ID when it can be derived safely. Memory comes from `torch.npu` with
+best-effort `npu-smi` telemetry; unavailable values are returned as `null`
+instead of being guessed.
+
+See [KeepGPU compatibility](https://github.com/pzheng460/keep-npu/blob/main/docs/compatibility.md)
+for the exact public-name mapping and intentional Ascend differences.
+
+## Development
+
+```console
+python -m pip install -e '.[dev]'
+PYTHONPATH=src python -m pytest
+cd web/dashboard && npm ci && npm test -- --run && npm run build
+```
+
+Hardware tests use the `ascend` pytest marker and conservative memory sizes.
+The original standalone `keep_npu_alive.py` entry point remains available for
+backward compatibility.

keep_npu-1.0.0/docs/compatibility.md

@@ -0,0 +1,34 @@
+# KeepGPU compatibility
+
+KeepNPU 1.0 follows KeepGPU 1.0's interaction model while translating the
+device backend from CUDA/ROCm/MPS to Huawei Ascend.
+
+| KeepGPU public contract | KeepNPU equivalent |
+| --- | --- |
+| `keep-gpu` | `keep-npu` |
+| `keep-gpu-mcp-server` | `keep-npu-mcp-server` |
+| `--gpu-ids` | `--npu-ids` |
+| `list-gpus` / `/api/gpus` | `list-npus` / `/api/npus` |
+| `gpu_ids` / `gpus` payload fields | `npu_ids` / `npus` |
+| `~/.keepgpu` | `~/.keepnpu` |
+| CUDA, ROCm, or MPS backend | Ascend `torch_npu` backend |
+
+The blocking CLI, background service commands, job lifecycle, REST resources,
+JSON-RPC methods, MCP tools, validation limits, dashboard flow, exit handling,
+and utilization-backoff policy otherwise retain the KeepGPU behavior.
+
+Intentional backend differences:
+
+- `torch_npu` is imported lazily so help, validation, and service health remain
+  usable on a machine without the Ascend runtime.
+- Device selectors are torch-visible ordinals. This avoids confusing a physical
+  card/chip ID with the post-filter ordinal accepted by `torch.npu.set_device`.
+- `npu-smi` formats differ across Ascend products and driver versions. KeepNPU
+  treats telemetry as best effort and returns nullable metrics when a value
+  cannot be established safely.
+- KeepNPU allocates float32 chunks and performs small in-place ReLU operations;
+  it does not assume CUDA-specific allocator or stream APIs. Ascend defaults to
+  one pass over the allocation per interval because KeepGPU's 5,000-pass GPU
+  default would generate roughly 10 TiB of memory traffic for a 1 GiB target.
+- Hardware/vendor setup is not declared as a PyPI dependency because PyTorch,
+  `torch_npu`, CANN, and the driver must be installed as a compatible set.

keep_npu-1.0.0/docs/releasing.md

@@ -0,0 +1,31 @@
+# Releasing KeepNPU
+
+KeepNPU publishes the normalized distribution name `keep-npu`. A release
+provides these commands after `python -m pip install keep-npu`:
+
+- `keep-npu`
+- `keep-npu-mcp-server`
+- `keep-npu-alive`
+
+## One-time PyPI setup
+
+Configure a pending trusted publisher for the `keep-npu` project with:
+
+- PyPI project name: `keep-npu`
+- GitHub owner: `pzheng460`
+- GitHub repository: `keep-npu`
+- Workflow filename: `publish-pypi.yml`
+- Environment name: `pypi`
+
+No long-lived PyPI token is stored in GitHub. PyPI verifies the GitHub Actions
+OIDC identity when the publish job runs.
+
+## Publish a version
+
+1. Update `__version__` and the matching `tool.bumpversion.current_version`.
+2. Run the Python, dashboard, build, and installed-wheel checks.
+3. Push the release commit and create a GitHub release tagged `vX.Y.Z`.
+4. The release event builds a fresh sdist and wheel, then publishes both through
+   PyPI trusted publishing.
+
+The workflow can also be started manually after the same tag/version checks.

keep_npu-1.0.0/docs/superpowers/plans/2026-07-21-keepgpu-parity.md

@@ -0,0 +1,162 @@
+# KeepGPU-Compatible KeepNPU Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build an Ascend-native `keep-npu` package whose renamed public interfaces and lifecycle behavior match KeepGPU 1.0.0/current compatibility fixes, then validate it on configured SSH NPU hosts.
+
+**Architecture:** Port the tested KeepGPU package, service, dashboard, and test boundaries with a deterministic GPU-to-NPU naming map. Replace the platform-specific controllers and telemetry with one dependency-injected Ascend backend using `torch_npu` and `npu-smi`, while retaining the upstream validation, protocol, concurrency, and daemon-safety contracts.
+
+**Tech Stack:** Python 3.9–3.13, setuptools, Typer, Rich, PyTorch + torch_npu, stdlib HTTP/JSON-RPC, React/Vite/Vitest/Tailwind, pytest.
+
+## Global Constraints
+
+- Reference behavior is KeepGPU upstream commit `691720383f5325cffb9fc5960304541caec31444` and release 1.0.0.
+- Public names use `keep-npu`, `keep-npu-mcp-server`, `--npu-ids`, `list-npus`, `npu_ids`, `npus`, and `~/.keepnpu`.
+- Default service endpoint is `127.0.0.1:8765`.
+- Unknown utilization is `null` and causes backoff unless `busy_threshold=-1`.
+- Remote work uses unique temporary directories and leaves no daemon or workload behind.
+- Production behavior is introduced only after a corresponding test has been observed failing.
+
+---
+
+### Task 1: Port the public contract and package skeleton
+
+**Files:**
+- Create: `pyproject.toml`
+- Create: `src/keep_npu/__init__.py`
+- Create: `src/keep_npu/utilities/*.py`
+- Create: `tests/utilities/*.py`
+- Create: `tests/test_package_metadata.py`
+- Modify: `.gitignore`
+
+**Interfaces:**
+- Produces: validators `validate_interval`, `validate_busy_threshold`, `validate_npu_ids`, `validate_job_id`; `parse_size`; strict JSON helpers; endpoint validators.
+- Consumes: no project interfaces.
+
+- [ ] Copy the upstream metadata and utility tests, mechanically map the approved public names, and run `pytest tests/utilities tests/test_package_metadata.py -q`; expect collection/import failure because `keep_npu` does not exist.
+- [ ] Add the mapped package metadata and utility modules, keeping numeric, size, endpoint, session-id, and strict-JSON limits unchanged.
+- [ ] Run `pytest tests/utilities tests/test_package_metadata.py -q`; expect all selected tests to pass.
+- [ ] Run `python -m build`; expect wheel and source distribution creation with both console entry points declared.
+- [ ] Commit with `feat: add KeepNPU package contracts`.
+
+### Task 2: Implement Ascend discovery, telemetry, and controllers
+
+**Files:**
+- Create: `src/keep_npu/utilities/platform_manager.py`
+- Create: `src/keep_npu/utilities/npu_info.py`
+- Create: `src/keep_npu/utilities/npu_monitor.py`
+- Create: `src/keep_npu/single_npu_controller/base_npu_controller.py`
+- Create: `src/keep_npu/single_npu_controller/ascend_npu_controller.py`
+- Create: `src/keep_npu/global_npu_controller/global_npu_controller.py`
+- Create: `tests/npu_controller/*.py`
+- Create: `tests/global_controller/*.py`
+- Create: `tests/fixtures/npu_smi/*.txt`
+
+**Interfaces:**
+- Consumes: Task 1 validators and size parsing.
+- Produces: `visible_torch_device_count()`, `list_npus()`, `NPUInfo`, `AscendNPUController`, and `GlobalNPUController`.
+
+- [ ] Port controller contract, timing, rollback, release, and health tests with fake Torch/NPU adapters; run them and expect import failure for controller modules.
+- [ ] Add `npu-smi` fixture tests for table parsing, missing fields, invalid utilization, inconsistent memory, and command failure; run and expect missing parser failures.
+- [ ] Implement lazy `torch`/`torch_npu` discovery and visible ordinal selection without importing hardware libraries during local validation.
+- [ ] Implement telemetry parsing that returns nullable fields and never converts unavailable utilization to zero.
+- [ ] Implement chunked float32 allocation, low-cost keepalive work, monotonic interval timing, utilization backoff, runtime health, idempotent keep/release, multi-device rollback, and parallel release.
+- [ ] Run `pytest tests/npu_controller tests/global_controller tests/utilities/test_npu_info.py tests/utilities/test_npu_monitor.py -q`; expect all selected tests to pass.
+- [ ] Commit with `feat: add Ascend NPU controllers and telemetry`.
+
+### Task 3: Port blocking CLI and legacy wrapper
+
+**Files:**
+- Create: `src/keep_npu/cli.py`
+- Create: `tests/test_cli_thresholds.py`
+- Create: `tests/test_cli_blocking.py`
+- Modify: `keep_npu_alive.py`
+- Modify: `README.md`
+
+**Interfaces:**
+- Consumes: `GlobalNPUController`, Task 1 validators.
+- Produces: `keep-npu` blocking mode and compatibility wrapper behavior.
+
+- [ ] Port the upstream blocking CLI tests with `--npu-ids`; add regression cases for `nan`, `inf`, duplicate IDs, signed zero, full-width digits, and root options before subcommands; run and expect CLI import/behavior failures.
+- [ ] Implement the Typer root command with defaults `interval=300`, `vram=1GiB`, `busy_threshold=25`, all-visible NPUs, legacy `--threshold`, and plain validation errors.
+- [ ] Convert `keep_npu_alive.py` into a wrapper that translates `--device`, `--interval`, and the legacy matrix-size flags into the new controller path while retaining `--once` as a bounded compatibility smoke operation.
+- [ ] Run `pytest tests/test_cli_thresholds.py tests/test_cli_blocking.py tests/test_keep_npu_alive.py -q`; expect all selected tests to pass.
+- [ ] Run `PYTHONPATH=src python -m keep_npu.cli --help`; expect mapped NPU options and all service subcommands.
+- [ ] Commit with `feat: add KeepNPU blocking CLI`.
+
+### Task 4: Port service lifecycle and service CLI
+
+**Files:**
+- Create: `src/keep_npu/mcp/server.py`
+- Create: `tests/mcp/test_server.py`
+- Create: `tests/test_cli_service_commands.py`
+
+**Interfaces:**
+- Consumes: `GlobalNPUController`, `list_npus()`, all shared validators.
+- Produces: `KeepNPUServer.start_keep`, `stop_keep`, `status`, `list_npus`; CLI `serve/start/status/stop/list-npus/service-stop`.
+
+- [ ] Port the upstream session concurrency, starting/stopping, runtime failure, release timeout, and status contract tests with the naming map; run and expect missing server failures.
+- [ ] Port service CLI tests for local validation, auto-start rollback, machine JSON purity, malformed RPC envelopes, ownership records, and safe daemon stop; run and expect missing commands.
+- [ ] Implement the shared session registry and lifecycle states without holding the registry lock during slow controller startup or health probes.
+- [ ] Implement CLI RPC clients, result validators, daemon auto-start, endpoint-specific logs/PID records, ownership verification, stop-all fallback, and command hints.
+- [ ] Run `pytest tests/mcp/test_server.py tests/test_cli_service_commands.py -q`; expect all selected tests to pass.
+- [ ] Commit with `feat: add KeepNPU service workflows`.
+
+### Task 5: Port REST, JSON-RPC, MCP, and dashboard
+
+**Files:**
+- Create: `tests/mcp/test_http_api.py`
+- Create: `web/dashboard/**`
+- Create: `src/keep_npu/mcp/static/index.html`
+- Create: `src/keep_npu/mcp/static/assets/*`
+
+**Interfaces:**
+- Consumes: `KeepNPUServer` direct methods.
+- Produces: REST `/api/npus` and session endpoints, JSON-RPC `/` and `/rpc`, stdio MCP lifecycle/tools, and the KeepNPU dashboard.
+
+- [ ] Port HTTP routing, strict request-body, JSON-RPC envelope, MCP lifecycle, method/error classification, HEAD/static asset, and dashboard API tests; run and expect route/asset failures.
+- [ ] Implement HTTP and stdio transports with exact NPU-native result keys and upstream route-hardening behavior.
+- [ ] Port dashboard source and tests with NPU labels and `/api/npus`; run `npm test -- --run` in `web/dashboard` and expect failures before mapped components are complete.
+- [ ] Complete the mapped React dashboard, run `npm run build`, and synchronize built assets into `src/keep_npu/mcp/static`.
+- [ ] Run `pytest tests/mcp -q` and `npm test -- --run`; expect all selected tests to pass.
+- [ ] Commit with `feat: add KeepNPU APIs and dashboard`.
+
+### Task 6: Full compatibility and packaging verification
+
+**Files:**
+- Create/modify: mapped remaining tests under `tests/`
+- Create: `docs/compatibility.md`
+- Modify: `README.md`
+- Modify: `MANIFEST.in`
+
+**Interfaces:**
+- Consumes: all prior public interfaces.
+- Produces: reproducible compatibility evidence and installable artifacts.
+
+- [ ] Port every remaining hardware-independent upstream test and run the full suite; record and fix each mapped contract failure using a failing regression test first.
+- [ ] Run `python -m pytest -q`, `ruff check .`, and `python -m compileall -q src tests keep_npu_alive.py`; expect clean output.
+- [ ] Build wheel/sdist, install the wheel into a temporary virtual environment, and smoke-test `keep-npu --help` plus `keep-npu-mcp-server --help`.
+- [ ] Build dashboard production assets and verify packaged assets match the React build.
+- [ ] Document the explicit name mapping, supported Python/CANN expectations, CLI/API examples, and known platform-only differences.
+- [ ] Commit with `test: complete KeepGPU compatibility coverage`.
+
+### Task 7: SSH Ascend validation and hardware corrections
+
+**Files:**
+- Create: `docs/validation/ascend-remote-results.md`
+- Create/modify: telemetry fixtures and regression tests discovered from hardware.
+- Modify: hardware modules only when a failing remote case is reproduced locally.
+
+**Interfaces:**
+- Consumes: built KeepNPU artifact and configured SSH hosts.
+- Produces: remote evidence, platform corrections, and cleanup verification.
+
+- [ ] Discover SSH host aliases read-only and preflight each reachable candidate with bounded commands for `npu-smi`, Python, CANN variables, `torch`, `torch_npu`, and device count.
+- [ ] Select at least two usable environments, or multiple devices on one host, based on availability and current memory pressure.
+- [ ] Rsync only source, tests, metadata, docs, and built dashboard assets to a unique `/tmp/keep-npu-<timestamp>` directory on each target.
+- [ ] Run remote unit smoke tests, `list-npus`, a low-memory short blocking session, and before/during/after telemetry; use explicit timeouts and capture logs.
+- [ ] Run service lifecycle, REST, JSON-RPC, MCP, dashboard endpoint, multi-NPU, invalid-selection, signal, repeated-stop, and rollback checks.
+- [ ] For each hardware discrepancy, add a local failing fixture/regression test, implement the smallest correction, rerun locally, redeploy, and rerun the affected remote check.
+- [ ] Stop all test sessions and services, verify no KeepNPU process remains, verify memory recovery, and remove each remote temporary directory.
+- [ ] Write exact host/runtime/device/version/result evidence and any irreducible Ascend differences to `docs/validation/ascend-remote-results.md`.
+- [ ] Run the complete local verification suite once more and commit with `test: validate KeepNPU on Ascend hardware`.