fix(package): 示例构建改用宿主工具链，跨平台不再 Exec format error

`build.sh all all` 此前必然失败：示例的跨平台是由 hmapdev 的 `--target` 完成的，
被执行的进程必须在当前机器上跑，而 build_examples 传的是**目标平台**那把工具链
→ darwin 目标下拿 darwin 二进制在 linux 上跑，报
"cannot execute binary file: Exec format error"（linux/amd64 之后的所有目标全灭）。

- 宿主平台在脚本顶部、**export GOOS/GOARCH 之前**取定（`go env GOOS` 在 export
  之后会返回目标平台，这正是原 bug 的成因），并用 `env -u GOOS -u GOARCH` 兜底；
- `all` 的第一个目标可能不是宿主平台 → 缺宿主工具链时先补建一次；
- 宿主工具链仍缺失则**显式报错并给出该跑哪条命令**，不再静默退化成 Exec format error。

验证（VERSION=1.2.0 bash package/build.sh all all）：
linux/amd64、linux/arm64、darwin/amd64、darwin/arm64 四个目标示例产物均 17/17 成功
（修复前 darwin 两个目标 0/17）；windows 目标仍按设计显式拒绝
（协议 2 的统一共享内存区未移植 Windows，走 WSL）。

.gitignore

@@ -1,6 +1,8 @@
 # Build artifacts
 *.so
 *.dll
+*.o
+*.exe
 *.hmap
 plugin.json
 
@@ -8,6 +10,11 @@ plugin.json
 build/
 dist/
 
+# plugindev 预编译二进制：只作为 release 附件分发，不进仓库历史。
+# 此前 5 个平台各 26-28MB 被 git 跟踪（约 137MB），每次重编都在历史里
+# 再叠一份，而它们本质是可从源码复现的产物。
+bin/
+
 # Test artifacts
 testdist/
 

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -2,6 +2,70 @@
 
 HomeAgent 插件开发 SDK，用于构建与 HomeAgent 平台交互的智能插件。
 
+## 版本与兼容性
+
+当前：**SDK 1.2.0**（需内核 **1.2.0+**）。
+
+**版本号跟随内核的中版本，patch 位恒为 `.0`**：
+
+| 内核版本 | 对应 SDK |
+|---|---|
+| 1.0.0 / 1.0.1 / … / 1.0.4 | 1.0.0 |
+| 1.1.0 / 1.1.1 / … / 1.1.N | **1.1.0** |
+| 1.2.0 起 | 1.2.0 |
+
+内核的 patch 位专用于 bugfix 与漏洞修复，不碰公开接口，所以 SDK 版本号不跟着动——
+否则你要么被迫跟版、要么怀疑自己版本过时，而接口其实一个字都没变。
+
+**1.0.x 插件升到 1.1.x：不需要改代码，也不需要重编。** 1.1.0 的新增全部是
+「插件调用、内核实现」方向，不调就不受影响（已用 SDK 0.9.2 编的旧 `plugin.bin`
+实测验证：在新内核上直接建链通过，因为握手校验的是 `ProtocolVersion`、不是 SDK 版本）。
+想用新字段时重编即可。
+
+**1.1.x 插件升到 1.2.x：接口纯追加，但必须重编。** 公开接口没有签名变更（新增
+`InjectOptions` 与六个 `*Opts` 变体、`ChannelDef.ContextPolicy`），不调新能力就不受影响；
+但内核的**插件运行协议升到了 2**（统一共享内存区的 fd3 布局改变，**不支持滚动升级**），
+所以 `plugin.bin` 必须用配套的 `hmapdev` 重编后与内核**同批**安装——否则握手时协议版本
+不匹配会被拒绝（错误信息会明确提示用配套 hmapdev 重编，不会静默降级）。
+
+## 注入行为与上下文裁剪（1.2.0）
+
+「记不记入记忆」与「要不要据此裁剪上下文」这两件事，原先只有 `ToolDef` 能声明；
+1.2.0 起**注入侧也能声明**，并且二者共用同一套语义与取值。
+
+```go
+type InjectOptions struct {
+	NoMemory      bool   // true = 不参与记忆计算（向量化/关键词提取/蒸馏），原文仍留在上下文
+	ContextPolicy string // ""/none = 不裁剪（默认）；prune = 据此裁剪上下文
+	CleanerName   string // 计算层过滤函数名：先经 Cleaner 得到实际有效内容，再计算/裁剪
+}
+
+const (
+	ContextPolicyNone  = "none"
+	ContextPolicyPrune = "prune"
+)
+
+// 六个变体，与旧的三参数方法一一对应，只多一个 opts
+InjectTextOpts(source, channel, text string, opts InjectOptions)
+InjectInterruptTextOpts(source, channel, text string, opts InjectOptions)
+InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string
+InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string
+InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+```
+
+要点：
+
+- **零值 `InjectOptions{}` 与旧的三参数方法逐键等价**（记入记忆 + 不裁剪）。旧方法保留为
+  零值糖（`InjectText` / `InjectInterruptText` / `InjectTextNoMemory` …），存量插件不改一行、
+  不需重编即可继续调用。
+- **裁剪（`prune`）必须显式声明**：它会归档丢弃低相关事件，是有副作用的行为，故默认关闭。
+  内核只放行 `""` / `none` / `prune`（`ValidContextPolicy`），未声明的取值会被拒。
+- 裁剪前先经该插件注册的 **`Cleaner`**（由 `CleanerName` 指定）拿到实际有效内容，
+  避开「按原文裁剪、按清洗后计算」这种不一致。
+- `ChannelDef` 也有同名 `context_policy`（并且 1.2.0 给它补上了 JSON tag——通道定义要跨进程
+  传给内核，而 `Cleaner` 是函数必须忽略；无 tag 时新增字段会被静默丢掉）。
+
 ## SDK API 接口
 
 ### Plugin 接口
@@ -36,6 +100,7 @@ type Plugin interface {
 | 设置 | `Settings()` | 访问设置 API |
 | 事件 | `Events()` | 访问事件订阅器（外部插件仅订阅） |
 | 注入 | `InjectText(source, channel, text)` / `InjectInterruptText(source, channel, text)` / `InjectTextNoMemory(source, channel, text)` | 向管道注入文本 |
+| 多模态注入 | `InjectInputMedia(source, channel, text, blocks)` / `InjectInputMediaSync(...)` / `InjectInterruptMedia(...)` | 注入带图片/音频的输入（1.1.0 新增） |
 | 自动重启 | `SetAutoRestart(enabled)` / `AutoRestart()` | 控制崩溃自动重启 |
 
 ### 阶段钩子
@@ -106,6 +171,30 @@ type 枚举值：
 | `InjectInterruptText(source, channel, text)` | 注入中断文本，打断当前处理，路由到指定通道 |
 | `InjectTextNoMemory(source, channel, text)` | 注入文本，不记入内存，路由到指定通道 |
 
+### 多模态注入（1.1.0 新增）
+
+| 方法 | 说明 |
+|------|------|
+| `InjectInputMedia(source, channel, text, blocks)` | 注入带媒体的输入，异步 |
+| `InjectInputMediaSync(source, channel, text, blocks)` | 注入带媒体的输入并同步等待回复文本 |
+| `InjectInterruptMedia(source, channel, text, blocks)` | 注入带媒体的中断，可抢占当前处理 |
+
+`blocks` 是 `[]sdk.ContentBlock`，与 `SetToolBlocks` 用同一类型：
+
+```go
+s.InjectInputMedia("myplugin", "webui", "帮我看看这张图", []sdk.ContentBlock{{
+    Type:     "image_url",
+    ImageURL: &sdk.ImageURL{URL: "data:image/png;base64," + b64, Detail: "auto"},
+}})
+```
+
+与 `SetToolBlocks` 的区别：`SetToolBlocks` 只能在工具处理函数内部调用，媒体要等到
+下一条 tool message 才到模型手上；这三个方法是插件**主动发起一轮带媒体的对话**，
+媒体在本轮就随消息发给模型，并自动落进媒体存储、挂上媒体记忆引用。
+
+媒体块里的 `data:` URL 会被内核落盘去重；`http(s)` URL 只透传给模型，不入库
+（入库需要内核发起网络请求，涉及超时、鉴权与 SSRF）。
+
 `source` 标识来源，`channel` 指定目标输出通道。
 
 ### Triple 扩展字段
@@ -115,6 +204,61 @@ Triple 数据结构新增字段：
 - `Confidence` — 置信度（0.0~1.0）
 - `SubjectType` — 主体类型
 - `ObjectType` — 客体类型
+- `SentenceText` — 原始句子文本（1.1.0 新增），写入 `sentences` 表；媒体引用挂在句子上
+- `MediaDigests` — 关联的媒体 digest 列表（1.1.0 新增）
+
+### 记忆里的媒体（1.1.0 新增）
+
+媒体在纯文本记忆里以**标记**形式存在，格式 `[<mime> <短digest>] <描述>`：
+
+```
+[image/png a1b2c3d4e5f6] 一张紫蓝红三色带图
+```
+
+描述文本是持久的语义记忆（检索靠它），digest 是回到字节的钥匙（反查靠它）。
+标记由内核生成，插件不必自己拼——**填 digest 就够**。
+
+#### 图记忆
+
+```go
+s.Memory().Commit([]sdk.Triple{{
+    Subject: "配色图", Relation: "包含", Object: "三色带",
+    MediaDigests: []string{"a1b2c3d4e5f6"}, // 短 digest 即可，内核补全
+}})
+```
+
+没给 `SentenceText` 时内核会用标记本身充当句子——媒体必须有句子落点，
+否则引用无从挂起。
+
+#### 知识库
+
+```go
+s.DocMemory().InsertWithMedia(&sdk.Doc{
+    Title:   "带图笔记",
+    Content: "正文",
+}, []sdk.MediaAttachment{
+    {MIME: "image/png", Data: pngBytes, Name: "chart.png"}, // 新内容，落盘去重
+    {Digest: "a1b2c3d4e5f6"},                               // 引用已有内容
+})
+```
+
+`Insert` 保持原签名不变，正文里已有的标记同样会被挂成文档级引用。
+`Query` 返回的 `Doc` 带 `MediaDigests` 与 `Attachments`（mime + 描述，
+**不含字节**——一次检索可能命中几十份媒体）。删除文档时引用自动释放。
+
+#### 文本记忆
+
+```go
+s.TextMemory().Append(sdk.TextEvent{
+    Role: "user", Content: "看这张图",
+    Attachments: []sdk.MediaAttachment{{MIME: "image/png", Data: pngBytes}},
+})
+```
+
+`RecentEvents` 读回时正文里的标记会被反解成 `Attachments`。
+
+媒体存储可在内核侧关闭（`core.memory.media.enabled=false`），此时以上接口
+全部退化为纯文本行为：不报错、不 panic，与本特性上线前一致。
 
 ### ToolDef 字段说明
 
@@ -140,22 +284,35 @@ func New(name string, sett SettingsAPI, regTool ToolRegistrar, regStage StageReg
 
 插件开发者只需实现 `Plugin` 接口并导出 `NewPluginFactory()` 入口函数。
 
-## plugindev 工具链
+## hmapdev 工具链
 
-`plugindev` 提供插件开发全流程支持。仓库 `bin/` 提供各平台预制二进制（linux/darwin/windows × amd64/arm64），下载后直接加入 PATH 即可：
+`hmapdev` 提供插件开发全流程支持，最终产出 `.hmap` 插件包（工具名即来自该包格式）。
+预编译二进制作为 **release 附件**分发（linux/darwin/windows × amd64/arm64），从
+[Releases](https://gitcode.com/JianFeeeee/homeagent-sdk/releases) 下载后加入 PATH 即可：
+
+> 改名说明：工具链原名 `plugindev`，自 1.2.0 起更名 `hmapdev`。
+> SDK 存储目录同时由 `~/.homeagent/plugindev/sdk` 迁到 `~/.homeagent/hmapdev/sdk`
+> （旧目录会被自动沿用，不会丢已装版本）。
 
 ```bash
-curl -o plugindev https://gitcode.com/JianFeeeee/homeagent-sdk/-/raw/main/bin/plugindev_linux_amd64
-chmod +x plugindev
+# 从 release 附件下载（以最新 SDK 发布 / linux amd64 为例）
+curl -Lo hmapdev https://gitcode.com/JianFeeeee/homeagent-sdk/releases/download/<版本>/hmapdev_linux_amd64
+chmod +x hmapdev
+
+# 或从源码自己编
+cd tools/hmapdev && go build -o hmapdev .
 ```
 
+> 二进制不再随仓库分发（旧的 `bin/` 目录已停用）：5 个平台各 26-28MB，
+> 每次重编都在 git 历史里再叠一份，而它们本质是可从源码复现的产物。
+
 | 命令 | 说明 |
 |------|------|
-| `plugindev init <name> [--lua]` | 初始化插件项目（生成 plg.json、plugin.go 或 main.lua、go.mod、README.md） |
-| `plugindev build [flags]` | 编译并打包为 `.hmap` 包（支持跨平台编译和 bundle 模式） |
-| `plugindev clean` | 清理 `build/`、`dist/` 目录及生成文件（plugin.json、z_bridge_gen.go） |
-| `plugindev debug [dir]` | 通过 Yaegi Go 解释器加载插件源码，启动交互式 REPL 调试 |
-| `plugindev sdk <command>` | SDK 版本管理（子命令：list/install/use/path/current/latest） |
+| `hmapdev init <name> [--lua]` | 初始化插件项目（生成 plg.json、plugin.go 或 main.lua、go.mod、README.md） |
+| `hmapdev build [flags]` | 编译并打包为 `.hmap` 包（支持跨平台编译和 bundle 模式） |
+| `hmapdev clean` | 清理 `build/`、`dist/` 目录及生成文件（plugin.json、z_bridge_gen.go） |
+| `hmapdev debug [dir]` | 通过 Yaegi Go 解释器加载插件源码，启动交互式 REPL 调试 |
+| `hmapdev sdk <command>` | SDK 版本管理（子命令：list/install/use/path/current/latest） |
 
 支持 **Go** 和 **Lua** 两种插件语言。
 
@@ -180,7 +337,7 @@ chmod +x plugindev
   "version": "1.0.0",
   "description": "天气查询插件",
   "author": "HomeAgent",
-  "entry": "plugin.so",
+  "entry": "plugin.bin",
   "tags": ["weather", "forecast"],
   "targets": "linux/amd64,windows/amd64",
   "outdir": "dist",
@@ -202,7 +359,7 @@ chmod +x plugindev
 | `version` | string | 版本号 |
 | `description` | string | 插件描述 |
 | `author` | string | 作者 |
-| `entry` | string | 入口文件（`plugin.so` / `plugin.dll` / `main.lua`） |
+| `entry` | string | 入口文件（`plugin.bin` / `main.lua`）。v1.0.0 起 Go 插件统一为 `plugin.bin`，不再区分平台后缀 |
 | `tags` | string[] | 标签 |
 | `targets` | string | 构建目标，逗号分隔（如 `linux/amd64,windows/amd64`，Lua 插件为 `lua`） |
 | `outdir` | string | 输出目录（默认 `dist`） |
@@ -217,11 +374,14 @@ chmod +x plugindev
 `.hmap` 为 ZIP 归档，包含：
 
 - `plugin.json` — 插件元数据
-- `plugin.so` — Go 编译产物（Linux）
-- `plugin.dll` — Go 编译产物（Windows）
-- `plugin.dylib` — Go 编译产物（macOS，bundle 模式）
+- `plugin.bin` — Go 编译产物（单平台构建）
+- `plugin.bin.<goos>.<goarch>` — 多平台 bundle 模式下每平台一份，
+  安装时 pluginmgr 挑当前平台那份重命名为 `plugin.bin`
 - `main.lua` — Lua 插件入口（Lua 插件时）
 
+> v1.0.0 起不再使用 `plugin.so`/`plugin.dll`/`plugin.dylib`——进程边界即 ABI 边界，
+> 不存在平台特定的动态库区分。旧产物新内核不会加载，会给出明确的重编提示。
+
 ## 插件生命周期
 
 ### 入口函数
@@ -259,7 +419,7 @@ return plugin
 
 - `sdk.RegisterOnRemoveHandler(fn func())` — 注册删除清理回调。内核在 `RemovePlugin` 流程中、插件 `Stop()` **之后**执行（后注册先执行，执行后清空、幂等）。用于删除插件自身创建的持久化文件（数据/缓存/状态文件）。
 - 内核卸载时一并清理：工具注册、`disabled_plugins` 记录、插件配置项定义（`plugin.<name>.*`）与插件配置表（`config_<name>`），卸载后插件配置区完全消失。
-- 示例：`example/calendar`（删 events.json）、`example/memo`（删 memos.json）、`example/rss`（删订阅数据目录）、`example/weather`（删缓存目录）；`plugindev` 模板含 onRemove 演示。
+- 示例：`example/calendar`（删 events.json）、`example/memo`（删 memos.json）、`example/rss`（删订阅数据目录）、`example/weather`（删缓存目录）；`hmapdev` 模板含 onRemove 演示。
 
 ```go
 sdk.RegisterOnRemoveHandler(func() {
@@ -277,6 +437,31 @@ enabled := sdk.AutoRestart()
 
 插件崩溃时平台自动拉起，保障服务可用性。
 
+> ⚠️ `SetAutoRestart` 的典型用法是「外部连接建好后再判定能否自动重启」，而连接建立
+> 通常在后台 goroutine 里，内核又在另一个 goroutine 读它——这对读写天然并发。
+> **SDK 1.1.0 已给这个标志与全部 API 字段加锁**（`-race` 实测 11 处竞态，
+> 生产表现是插件重载瞬间偶发 nil 解引用崩溃）。早于 1.1.0 的版本建议升级。
+
+## 插件开发者的并发约定
+
+`PluginSDK` 是**被多个 goroutine 同时使用的共享对象**：你在 `Start()` 里起的轮询、
+监听、定时器都拿着同一份 `*PluginSDK` 往里注消息，而内核会在加载/重载时写它的
+ API 字段。因此：
+
+- **SDK 侧已保证的**：全部 API 访问器（`Memory()`/`DocMemory()`/…）、全部注入方法、
+  `SetAutoRestart`/`AutoRestart`、`RegisterTool`/`RegisterStage`、
+  `RunStopHandlers`/`RunOnRemoveHandlers`（幂等，并发调也只执行一次）。
+- **你需要自己保证的**：`StageContext` 的字段全部导出，并发读写必须自己持
+  `ctx.Lock()`/`ctx.RLock()`。尤其是 `ctx.Extra`——**map 的并发写在 Go 里是直接 fatal，
+  `recover` 接不住**。
+
+```go
+ctx.Lock()
+ctx.Extra["mykey"] = value
+ctx.FinalText += "补充说明"
+ctx.Unlock()
+```
+
 ## 受限 SDK vs 完整 SDK
 
 外部插件（第三方分发）使用**受限 SDK**，仅暴露安全子集：
@@ -308,15 +493,338 @@ enabled := sdk.AutoRestart()
 | [rss](example/rss) | Go | RSS 订阅 |
 | [sanitizer](example/sanitizer) | Go | 内容清洗/安全过滤 |
 
+**发版时附带预编译示例产物**：SDK 的 release 除 5 平台 `hmapdev` 外，还包含各示例插件的
+`.hmap` 与 `SHA256SUMS`/`MANIFEST.txt`。原因是插件二进制与内核**协议绑定**（`ProtocolVersion`
++ 共享内存区魔数），只发工具链不发示例产物，很容易拿旧产物去装而握手失败——那看起来像
+「插件坏了」而不是「版本不配套」。
+
+## Remote Device SDK
+
+用于开发**远程设备接入适配器**的 C 语言 SDK，零外部依赖，兼容嵌入式平台。
+
+### 架构
+
+```
+┌─────────────────────────────────────────────────┐
+│            ha_remotedevice (C SDK)              │
+│  协议引擎  │  WS 帧  │  JSON  │  状态机  │ 传输抽象  │
+└──────────┬──────────────────────────────────────┘
+           │  同一份 C 代码，设备端和 App 端共用
+    ┌──────┴──────────────────┐
+    ▼                         ▼
+┌──────────────┐    ┌──────────────────────────┐
+│  ESP32 裸机   │    │  Linux 设备上的 App        │
+│  纯 C 直调     │    │  (Python ctypes / Go CGo / │
+│  简单命令处理   │    │   Node addon / C# P/Invoke) │
+└──────────────┘    └──────────────────────────┘
+```
+
+### 声明式 API 设计
+
+设备在代码中声明**自己是什么**、**能做什么**、**支持哪些命令**，每个命令对应独立处理函数，SDK 自动分发并回执结果：
+
+```c
+#include "ha_remotedevice.h"
+
+/* 声明能力 */
+const char *caps[] = {"camera", "status", NULL};
+
+/* 声明式命令处理表：每个命令绑定独立处理函数 */
+static ha_status_t handle_camerasue(const char *req_id, const char *args,
+                                    ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    int duration = args[0] ? atoi(args) : 0;
+    // 拍照/录像...
+    result->status = 0;
+    result->output = "data:image/jpeg;base64,...";  // SDK 自动回执
+    return HA_OK;
+}
+
+ha_cmd_handler_def_t handlers[] = {
+    {.command = "shell",      .handler = handle_shell},
+    {.command = "camerasue",  .handler = handle_camerasue},
+    {.command = "screensee",  .handler = handle_screensee},
+    {.command = "speakeruse", .handler = handle_speakeruse},
+    {.command = NULL},  /* 标记结束 */
+};
+
+ha_config_t config = {
+    .transport = my_transport,     // 用户实现 4 个函数
+    .server    = "192.168.1.100:9890",
+    .token     = "my-token",
+    .device = {
+        .device_id = "esp32-cam-1",
+        .name      = "门口摄像头",
+        .kind      = "camera",
+        .caps      = caps,
+    },
+    .handlers  = handlers,   // 声明式命令处理表
+    .on_state  = my_state_handler,
+};
+
+ha_client_t *client = ha_client_new(&config);
+ha_client_start(client);
+while (1) {
+    ha_client_process(client);     // 主循环处理
+}
+```
+
+### 传输层抽象
+
+用户只需实现 4 个函数，适配不同平台：
+
+```c
+ha_transport_t my_transport = {
+    .connect = my_tcp_connect,   // 建立 TCP 连接
+    .send    = my_tcp_send,      // 发送数据
+    .recv    = my_tcp_recv,      // 接收数据（阻塞）
+    .close   = my_tcp_close,     // 关闭连接
+    .ctx     = &my_platform_ctx,
+};
+```
+
+### 支持的协议
+
+| 功能 | API |
+|------|-----|
+| WS 连接 + 握手 | `ha_client_start` 自动完成 |
+| 设备注册 (hello/bind) | 启动时自动发送 |
+| 命令接收 (shell/homeagent) | `handlers` 表声明式注册，SDK 自动分发 |
+| 命令回执 | `ha_client_send_result` |
+| 二进制分块（录像等） | `ha_client_send_data_chunked` |
+| TTS 音频接收 | `on_binary` 回调 |
+| 事件上报 | `ha_client_send_event` |
+| 状态上报 | `ha_client_send_status` |
+| 心跳保持 | 自动 ping/pong |
+
+### 使用方式
+
+通过 `hmapdev` 工具链初始化项目：
+
+```bash
+hmapdev init my-adapter --type remotedevice
+```
+
+生成 `main.c` + `CMakeLists.txt`，可直接编译或作为三方库引入：
+
+```cmake
+add_subdirectory(path/to/ha_remotedevice)
+target_link_libraries(my_app ha_remotedevice)
+target_include_directories(my_app PRIVATE ${HA_REMOTEDEVICE_INCLUDE_DIR})
+```
+
+### 快速接入指南
+
+以下是从零到设备成功接入 HomeAgent 的完整步骤。
+
+#### 1. 准备工作
+
+在 HomeAgent 平台上创建接入令牌：
+
+```bash
+# 在 HomeAgent 服务端创建一个设备接入令牌
+curl -X POST http://<homeagent-server>:8080/api/v1/device/token \
+  -H "Content-Type: application/json" \
+  -d '{"device_id":"esp32-cam-1","name":"门口摄像头","kind":"camera"}'
+# 返回: {"token":"ha-dev-token-xxxxx"}
+```
+
+记录下返回的 `token`，设备端配置时使用。
+
+#### 2. 实现传输层（4 个函数）
+
+根据你的平台实现 `ha_transport_t` 的 4 个函数指针。以下是几种常见场景：
+
+**场景 A：带 TCP/IP 栈的嵌入式设备（如 ESP32 + lwIP）**
+
+```c
+#include "ha_remotedevice.h"
+#include "lwip/sockets.h"
+
+static int esp_connect(void *ctx, const char *host, uint16_t port) {
+    struct sockaddr_in addr;
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) return -1;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    inet_pton(AF_INET, host, &addr.sin_addr);
+    int ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
+    if (ret < 0) { closesocket(sock); return -1; }
+    *(int *)ctx = sock;
+    return 0;
+}
+
+static int esp_send(void *ctx, const uint8_t *data, int len) {
+    int sock = *(int *)ctx;
+    return send(sock, (const char *)data, len, 0);
+}
+
+static int esp_recv(void *ctx, uint8_t *buf, int len) {
+    int sock = *(int *)ctx;
+    return recv(sock, (char *)buf, len, 0);
+}
+
+static void esp_close(void *ctx) {
+    int sock = *(int *)ctx;
+    closesocket(sock);
+}
+
+int esp_ctx = -1;
+ha_transport_t transport = {
+    .connect = esp_connect,
+    .send    = esp_send,
+    .recv    = esp_recv,
+    .close   = esp_close,
+    .ctx     = &esp_ctx,
+};
+```
+
+**场景 B：通过串口（UART）连接透传模块**
+
+```c
+static int uart_connect(void *ctx, const char *host, uint16_t port) {
+    (void)host; (void)port;
+    // 初始化 UART，波特率 115200
+    return uart_init((uart_ctx_t *)ctx, 115200);
+}
+
+static int uart_send(void *ctx, const uint8_t *data, int len) {
+    return uart_write((uart_ctx_t *)ctx, data, len);
+}
+
+static int uart_recv(void *ctx, uint8_t *buf, int len) {
+    return uart_read((uart_ctx_t *)ctx, buf, len);
+}
+
+static void uart_close(void *ctx) {
+    uart_deinit((uart_ctx_t *)ctx);
+}
+```
+
+> 注意：UART 透传时，另一端需运行一个 TCP 桥接程序，将串口数据转发到 HomeAgent 的 WebSocket 端口。
+
+#### 3. 声明设备能力和命令处理
+
+```c
+#include "ha_remotedevice.h"
+
+/* 声明设备能力 */
+const char *caps[] = {"camera", "speaker", "status", NULL};
+
+/* 处理 camerasue 命令（拍照） */
+static ha_status_t handle_camera(const char *req_id, const char *args,
+                                 ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    int duration = args[0] ? atoi(args) : 0;  // 参数：录像时长
+
+    // 拍照或录像，将结果填入 result
+    result->status = 0;
+    result->output = "data:image/jpeg;base64,/9j/4AAQ...";  // base64 图像数据
+    return HA_OK;
+}
+
+/* 处理 shell 命令 */
+static ha_status_t handle_shell(const char *req_id, const char *args,
+                                ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    // 执行 shell 命令，args 为完整命令字符串
+    result->status = 0;
+    result->output = "command executed";
+    return HA_OK;
+}
+
+/* 声明式命令处理表 */
+ha_cmd_handler_def_t handlers[] = {
+    {.command = "shell",      .handler = handle_shell},
+    {.command = "camerasue",  .handler = handle_camera},
+    {.command = "screensee",  .handler = handle_camera},
+    {.command = "speakeruse", .handler = handle_speaker},
+    {.command = NULL},  /* 标记结束 */
+};
+```
+
+#### 4. 配置并启动客户端
+
+```c
+ha_config_t config = {
+    .transport = transport,                 // 传输层实现
+    .server    = "192.168.1.100:9890",      // HomeAgent 服务端地址
+    .token     = "ha-dev-token-xxxxx",      // 第 1 步获取的令牌
+    .device = {
+        .device_id = "esp32-cam-1",
+        .name      = "门口摄像头",
+        .kind      = "camera",
+        .caps      = caps,
+        .info_json = "{\"chip\":\"ESP32-S3\",\"firmware\":\"v1.0\"}",
+    },
+    .handlers  = handlers,                  // 命令处理表
+    .on_binary = on_binary_data,            // 接收 TTS 音频等二进制数据
+    .on_state  = on_state_change,           // 连接状态变化回调
+    .ping_interval = 30,                    // 心跳间隔秒数
+};
+
+ha_client_t *client = ha_client_new(&config);
+ha_status_t ret = ha_client_start(client);
+if (ret != HA_OK) {
+    printf("设备接入失败: %d\n", ret);
+    return;
+}
+
+/* 主循环 */
+while (1) {
+    ha_client_process(client);  // 处理协议帧、心跳、命令分发
+
+    /* 可选：设备主动上报事件 */
+    ha_client_send_event(client, "motion_detected",
+                         "{\"zone\":\"front_door\",\"confidence\":0.95}");
+
+    /* 可选：上报设备状态 */
+    ha_client_send_status(client, "online");
+
+    vTaskDelay(100 / portTICK_PERIOD_MS);  // 嵌入式 RTOS 风格延时
+}
+```
+
+#### 5. 验证连接
+
+在 HomeAgent 服务端检查设备是否在线：
+
+```bash
+# 查看已注册设备列表
+curl http://<homeagent-server>:8080/api/v1/device/list
+# 预期输出包含: {"device_id":"esp32-cam-1","status":"online",...}
+
+# 向设备发送命令（测试 camerasue）
+curl -X POST http://<homeagent-server>:8080/api/v1/device/esp32-cam-1/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"cmd":"camerasue","args":"3"}'
+# 预期返回: {"status":"ok","result":"data:image/jpeg;base64,..."}
+```
+
+#### 6. 调试技巧
+
+| 问题 | 检查点 |
+|------|--------|
+| 连接失败 | 确认 `server` 地址和端口可通；检查 `token` 是否正确 |
+| WS 握手失败 | 确认 HomeAgent 服务端已开启 WebSocket 支持 |
+| 命令无响应 | 确认 `handlers` 表中注册了对应命令名；检查 `on_binary` 是否配置 |
+| 断线重连 | `max_reconnect` 控制重连次数，-1 为无限重连 |
+| 内存不足（嵌入式） | 定义 `HA_NO_ALLOC` 宏禁用动态内存分配 |
+
+### 位置
+
+- **SDK 源码**: `remotedevice/`
+- **hmapdev 模板**: `hmapdev init --type remotedevice`
+
 ## 构建与安装
 
 ### 构建
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
-输出 `.hmap` 包到 `dist/` 目录（默认 bundle 多平台合集；单平台构建使用 `plugindev build --no-bundle`）。
+输出 `.hmap` 包到 `dist/` 目录（默认 bundle 多平台合集；单平台构建使用 `hmapdev build --no-bundle`）。
 
 ### 安装
 
@@ -334,3 +842,16 @@ curl -X POST http://127.0.0.1:9876/plugins \
 ```
 
 或通过 WebUI 插件管理页面上传，也可手动将 `.hmap` 放入插件目录后重启平台。
+
+## 许可
+
+SDK 以 **AGPL-3.0-only** 发布，全文见 [LICENSE](LICENSE)。
+
+**这对插件开发者是实质性约束**：SDK 会随插件一起**静态链接**（其源码进入插件二进制），
+插件因此是本 SDK 的衍生作品，**必须以相同许可（AGPL-3.0-only）发布**；并且因为 AGPL §13
+覆盖网络交互，通过 HTTP/WebSocket 等向用户提供服务的插件同样要向使用者提供源码。
+若你的插件需要闭源，唯一合规路径是另行取得本项目的例外/商业授权——目前不提供。
+
+第三方组件（Go 依赖：go-sqlite3、gojieba、bubbletea 等，均为 MIT / BSD-3 / Apache-2.0）
+保持各自原有许可。平台侧的模型与推理运行时（Chinese-CLIP Apache-2.0、ONNX Runtime MIT）
+不属于本 SDK，其许可全文随发行包放在 `/usr/share/doc/homeagent/licenses/`。

README_EN.md

@@ -2,6 +2,83 @@
 
 Plugin development SDK for building intelligent plugins that interact with the HomeAgent platform.
 
+## Version and Compatibility
+
+Current: **SDK 1.2.0** (requires kernel **1.2.0+**).
+
+**The version tracks the kernel's minor version, with the patch position pinned at `.0`**:
+
+| Kernel version | Matching SDK |
+|---|---|
+| 1.0.0 / 1.0.1 / … / 1.0.4 | 1.0.0 |
+| 1.1.0 / 1.1.1 / … / 1.1.N | **1.1.0** |
+| 1.2.0 onward | 1.2.0 |
+
+The kernel's patch position is reserved for bugfixes and vulnerability fixes, which never touch the
+public interface, so the SDK version has no reason to move with it — otherwise you would either be
+forced to chase releases or suspect your version is stale, when not one character of the interface
+has changed.
+
+**Upgrading a 1.0.x plugin to 1.1.x: no code changes, no rebuild.** Everything added in 1.1.0 is
+in the "plugin calls, kernel implements" direction, so not calling it means not being affected
+(verified with an old `plugin.bin` built against SDK 0.9.2: it handshakes fine on the new kernel,
+because the handshake validates `ProtocolVersion`, not the SDK version). Rebuild only when you want
+the new fields.
+
+**Upgrading a 1.1.x plugin to 1.2.x: the interface is purely additive, but a rebuild is required.**
+No public signature changed (the SDK adds `InjectOptions`, six `*Opts` variants and
+`ChannelDef.ContextPolicy`), so not calling the new capabilities means not being affected — but the
+kernel's **plugin protocol went to 2** (the fd3 layout of the unified shared-memory region changed,
+and **rolling upgrades are not supported**). `plugin.bin` must therefore be rebuilt with the matching
+`hmapdev` and installed **together with** the kernel; otherwise the handshake fails on protocol
+version mismatch (the error says explicitly to rebuild with the matching hmapdev — it never
+degrades silently).
+
+## Injection Behaviour and Context Pruning (1.2.0)
+
+"Should this go into memory" and "should the context be pruned based on this" used to be
+something only `ToolDef` could declare. Since 1.2.0 **injections can declare them too**, sharing
+the same semantics and values.
+
+```go
+type InjectOptions struct {
+	NoMemory      bool   // true = excluded from memory computation (vectorize/keywords/distill); the
+	                     //        original text still stays in context
+	ContextPolicy string // ""/none = do not prune (default); prune = prune context based on this
+	CleanerName   string // name of the compute-layer cleaner: run it first to get the effective
+	                     // content, then compute/prune on that
+}
+
+const (
+	ContextPolicyNone  = "none"
+	ContextPolicyPrune = "prune"
+)
+
+// Six variants, one-to-one with the older three-argument methods, plus opts
+InjectTextOpts(source, channel, text string, opts InjectOptions)
+InjectInterruptTextOpts(source, channel, text string, opts InjectOptions)
+InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string
+InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string
+InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+```
+
+Key points:
+
+- **A zero-valued `InjectOptions{}` is key-for-key equivalent to the older three-argument methods**
+  (recorded in memory, not pruned). The old methods remain as zero-value sugar (`InjectText`,
+  `InjectInterruptText`, `InjectTextNoMemory`, …), so existing plugins keep working without a single
+  line changed *or* a rebuild.
+- **Pruning (`prune`) must be declared explicitly**: it archives/drops low-relevance events, which
+  is a side effect, so it is off by default. The kernel only accepts `""` / `none` / `prune`
+  (`ValidContextPolicy`); anything else is rejected.
+- Pruning first goes through the plugin's registered **`Cleaner`** (named by `CleanerName`) to get
+  the effective content, avoiding the inconsistency of "prune on the raw text, compute on the
+  cleaned text".
+- `ChannelDef` carries the same `context_policy` (1.2.0 also gave `ChannelDef` JSON tags — the
+  definition crosses the process boundary, while `Cleaner` is a function that must be ignored; with
+  no tags, newly added fields would be silently dropped).
+
 ## SDK API Surface
 
 ### Plugin Interface
@@ -36,6 +113,7 @@ The SDK instance injected via `Start(sdk *PluginSDK)` provides:
 | Settings | `Settings()` | Access settings API |
 | Events | `Events()` | Access event subscriber (subscribe-only for external plugins) |
 | Inject | `InjectText(source, channel, text)` / `InjectInterruptText(source, channel, text)` / `InjectTextNoMemory(source, channel, text)` | Inject text into the agent pipeline |
+| Media inject | `InjectInputMedia(source, channel, text, blocks)` / `InjectInputMediaSync(...)` / `InjectInterruptMedia(...)` | Inject input carrying images/audio (added in 1.1.0) |
 | Auto-Restart | `SetAutoRestart(enabled)` / `AutoRestart()` | Control automatic restart on crash |
 
 ### Stage Hooks
@@ -106,6 +184,32 @@ Type enum values:
 | `InjectInterruptText(source, channel, text)` | Inject interrupt text, interrupt current processing, route to specified channel |
 | `InjectTextNoMemory(source, channel, text)` | Inject text without memory recording, route to specified channel |
 
+### Multimodal Injection (added in 1.1.0)
+
+| Method | Description |
+|--------|-------------|
+| `InjectInputMedia(source, channel, text, blocks)` | Inject media-bearing input, asynchronous |
+| `InjectInputMediaSync(source, channel, text, blocks)` | Inject media-bearing input and wait for the reply text |
+| `InjectInterruptMedia(source, channel, text, blocks)` | Inject a media-bearing interrupt that can preempt current processing |
+
+`blocks` is `[]sdk.ContentBlock`, the same type `SetToolBlocks` takes:
+
+```go
+s.InjectInputMedia("myplugin", "webui", "take a look at this", []sdk.ContentBlock{{
+    Type:     "image_url",
+    ImageURL: &sdk.ImageURL{URL: "data:image/png;base64," + b64, Detail: "auto"},
+}})
+```
+
+How this differs from `SetToolBlocks`: that one is only callable inside a tool handler and
+its media reaches the model with the *next* tool message. These three let a plugin
+**initiate a turn that carries media** — the media goes out with this turn's message and is
+automatically stored in the media store with a memory reference attached.
+
+`data:` URLs in the blocks are stored and deduplicated by the kernel; `http(s)` URLs are
+passed to the model only and never stored (storing them would require the kernel to make
+network requests, bringing timeouts, auth and SSRF into scope).
+
 `source` identifies the origin, `channel` specifies the target output channel.
 
 ### Triple Extended Fields
@@ -115,6 +219,65 @@ The Triple data structure includes additional fields:
 - `Confidence` — confidence score (0.0–1.0)
 - `SubjectType` — subject type
 - `ObjectType` — object type
+- `SentenceText` — the original sentence (added in 1.1.0), written to the `sentences` table; media references hang off the sentence
+- `MediaDigests` — associated media digests (added in 1.1.0)
+
+### Media in Memory (added in 1.1.0)
+
+Inside plain-text memory, media is represented as a **marker** of the form
+`[<mime> <short digest>] <description>`:
+
+```
+[image/png a1b2c3d4e5f6] a purple-blue-red three-band chart
+```
+
+The description is the durable semantic memory (retrieval uses it); the digest is the key
+back to the bytes (reverse lookup uses it). Markers are generated by the kernel — a plugin
+never has to assemble one, it just **supplies the digest**.
+
+#### Graph memory
+
+```go
+s.Memory().Commit([]sdk.Triple{{
+    Subject: "palette", Relation: "contains", Object: "three-band",
+    MediaDigests: []string{"a1b2c3d4e5f6"}, // short digest is fine, the kernel resolves it
+}})
+```
+
+With no `SentenceText`, the kernel uses the marker itself as the sentence — media must have
+a sentence to hang off, otherwise the reference has nowhere to attach.
+
+#### Knowledge base
+
+```go
+s.DocMemory().InsertWithMedia(&sdk.Doc{
+    Title:   "illustrated note",
+    Content: "body",
+}, []sdk.MediaAttachment{
+    {MIME: "image/png", Data: pngBytes, Name: "chart.png"}, // new content, stored and deduped
+    {Digest: "a1b2c3d4e5f6"},                               // reference existing content
+})
+```
+
+`Insert` keeps its original signature; markers already present in the body are bound as
+document-level references too. `Query` fills `MediaDigests` and `Attachments` (mime plus
+description, **no bytes** — one query can match dozens of media items). Removing a document
+releases its references.
+
+#### Text memory
+
+```go
+s.TextMemory().Append(sdk.TextEvent{
+    Role: "user", Content: "look at this",
+    Attachments: []sdk.MediaAttachment{{MIME: "image/png", Data: pngBytes}},
+})
+```
+
+`RecentEvents` decodes markers in the body back into `Attachments`.
+
+The media store can be disabled kernel-side (`core.memory.media.enabled=false`); all of the
+above then degrades to plain-text behaviour — no errors, no panics, identical to how it
+behaved before this feature shipped.
 
 ### ToolDef Field Reference
 
@@ -140,16 +303,37 @@ func New(name string, sett SettingsAPI, regTool ToolRegistrar, regStage StageReg
 
 Plugin developers only need to implement the `Plugin` interface and export a `NewPlugin()` entry function.
 
-## plugindev Toolchain
+## hmapdev Toolchain
 
-`plugindev` provides full development workflow support:
+`hmapdev` provides full development workflow support and produces `.hmap` plugin bundles (the tool is
+named after that package format). Prebuilt binaries ship as **release assets**
+(linux/darwin/windows × amd64/arm64); download from
+[Releases](https://gitcode.com/JianFeeeee/homeagent-sdk/releases) and put it on your PATH:
+
+> Rename note: the toolchain was called `plugindev` and is `hmapdev` since 1.2.0.
+> The SDK store moved from `~/.homeagent/plugindev/sdk` to `~/.homeagent/hmapdev/sdk`
+> (the old directory is still honored, so installed versions are not lost).
+
+```bash
+# From release assets (latest SDK release / linux amd64 shown)
+curl -Lo hmapdev https://gitcode.com/JianFeeeee/homeagent-sdk/releases/download/<version>/hmapdev_linux_amd64
+chmod +x hmapdev
+
+# Or build from source
+cd tools/hmapdev && go build -o hmapdev .
+```
+
+> Binaries no longer ship inside the repository (the old `bin/` directory is retired): five
+> platforms at 26-28MB each piled another copy into git history on every rebuild, and they are
+> reproducible from source anyway.
 
 | Command | Description |
 |---------|-------------|
-| `plugindev init` | Initialize plugin project (generates plg.json, entry template) |
-| `plugindev build` | Build plugin, output .hmap package |
-| `plugindev clean` | Clean build artifacts |
-| `plugindev debug` | Run plugin in local debug mode |
+| `hmapdev init <name> [--lua]` | Initialize plugin project (generates plg.json, plugin.go or main.lua, go.mod, README.md) |
+| `hmapdev build [flags]` | Build and package into a `.hmap` (supports cross-compilation and bundle mode) |
+| `hmapdev clean` | Clean `build/` and `dist/` plus generated files |
+| `hmapdev debug [dir]` | Load plugin source through the Yaegi Go interpreter and start an interactive REPL |
+| `hmapdev sdk <command>` | SDK version management (list/install/use/path/current/latest) |
 
 Supports both **Go** and **Lua** plugin languages.
 
@@ -163,7 +347,7 @@ Supports both **Go** and **Lua** plugin languages.
   "version": "1.0.0",
   "description": "Weather plugin",
   "author": "HomeAgent",
-  "entry": "plugin.so",
+  "entry": "plugin.bin",
   "tags": ["weather", "forecast"],
   "targets": "linux/amd64,windows/amd64",
   "outdir": "dist",
@@ -185,7 +369,7 @@ Supports both **Go** and **Lua** plugin languages.
 | `version` | string | Version |
 | `description` | string | Plugin description |
 | `author` | string | Author |
-| `entry` | string | Entry file (`plugin.so` / `main.lua`) |
+| `entry` | string | Entry file (`plugin.bin` / `main.lua`). Since v1.0.0 Go plugins uniformly build to `plugin.bin`—no per-platform suffix |
 | `tags` | string[] | Tags |
 | `targets` | string | Build targets, comma-separated (e.g. `linux/amd64,windows/amd64`) |
 | `outdir` | string | Output directory (default `dist`) |
@@ -198,10 +382,15 @@ Supports both **Go** and **Lua** plugin languages.
 `.hmap` is a ZIP archive containing:
 
 - `plugin.json` — plugin metadata
-- `plugin.so` — Go compiled artifact (Linux)
-- `plugin.dll` — Go compiled artifact (Windows)
+- `plugin.bin` — Go compiled artifact (single-platform build)
+- `plugin.bin.<goos>.<goarch>` — one per platform in bundle mode; on install pluginmgr picks
+  the one matching the current platform and renames it to `plugin.bin`
 - `main.lua` — Lua plugin entry (for Lua plugins)
 
+> Since v1.0.0 `plugin.so`/`plugin.dll`/`plugin.dylib` are no longer used—the process boundary
+> *is* the ABI boundary, so there is no platform-specific shared-library distinction. The new
+> kernel will not load old artifacts; it emits an explicit rebuild hint instead.
+
 ## Plugin Lifecycle
 
 ### Start & Stop
@@ -216,7 +405,7 @@ Supports both **Go** and **Lua** plugin languages.
 
 - `sdk.RegisterOnRemoveHandler(fn func())` — Register a remove cleanup callback. The kernel runs it **after** the plugin's `Stop()` in the `RemovePlugin` flow (LIFO order, cleared after running — idempotent). Use it to delete persistent files the plugin created itself (data/cache/state files).
 - The kernel also cleans up on uninstall: tool registrations, the `disabled_plugins` record, the plugin's config definitions (`plugin.<name>.*`) and its config table (`config_<name>`) — the plugin's config section disappears completely after removal.
-- Examples: `example/calendar` (removes events.json), `example/memo` (removes memos.json), `example/rss` (removes the subscription data dir), `example/weather` (removes the cache dir); the `plugindev` template includes an onRemove demo.
+- Examples: `example/calendar` (removes events.json), `example/memo` (removes memos.json), `example/rss` (removes the subscription data dir), `example/weather` (removes the cache dir); the `hmapdev` template includes an onRemove demo.
 
 ```go
 sdk.RegisterOnRemoveHandler(func() {
@@ -234,6 +423,33 @@ enabled := sdk.AutoRestart()
 
 The platform automatically restarts the plugin on crash, ensuring service availability.
 
+> ⚠️ `SetAutoRestart` is typically used to decide whether auto-restart is safe *after* an
+> external connection has been established, and that connection setup usually happens in a
+> background goroutine while the kernel reads the flag from another one — which is inherently
+> concurrent. **SDK 1.1.0 locks this flag and all API fields** (`-race` reported 11 data races;
+> in production this showed up as sporadic nil-dereference crashes during plugin reload). Upgrade
+> if you are on anything earlier.
+
+## Concurrency Contract for Plugin Developers
+
+`PluginSDK` is a **shared object used by multiple goroutines**: the polling, listening and timer
+callbacks you start in `Start()` all hold the same `*PluginSDK` and push messages into it, while
+the kernel writes its API fields during load/reload. So:
+
+- **Guaranteed by the SDK**: all API accessors (`Memory()`/`DocMemory()`/…), all injection methods,
+  `SetAutoRestart`/`AutoRestart`, `RegisterTool`/`RegisterStage`, and
+  `RunStopHandlers`/`RunOnRemoveHandlers` (idempotent; concurrent calls still run it once).
+- **Your responsibility**: every field of `StageContext` is exported, and concurrent read/write
+  must hold `ctx.Lock()`/`ctx.RLock()`. Especially `ctx.Extra` — **concurrent map writes are a
+  fatal in Go, and `recover` cannot catch it**.
+
+```go
+ctx.Lock()
+ctx.Extra["mykey"] = value
+ctx.FinalText += "supplementary note"
+ctx.Unlock()
+```
+
 ## Restricted SDK vs Full SDK
 
 External plugins (third-party distribution) use a **restricted SDK** that only exposes a safe subset:
@@ -265,15 +481,321 @@ Internal plugins (platform built-in) have full SDK access including SocialAPI wr
 | [rss](example/rss) | Go | RSS subscriptions |
 | [sanitizer](example/sanitizer) | Go | Content sanitization / safety filtering |
 
+**Prebuilt example artifacts ship with every release**: besides the 5-platform `hmapdev`, an SDK
+release contains the example plugins' `.hmap` files plus `SHA256SUMS`/`MANIFEST.txt`. The reason is
+that plugin binaries are **protocol-bound** to the kernel (`ProtocolVersion` + the shared-memory
+magic), so shipping the toolchain without matching artifacts invites installing an old artifact —
+which fails the handshake and looks like "the plugin is broken" rather than "the versions don't
+match".
+
+## Remote Device SDK
+
+A C language SDK for developing **remote device access adapters** with zero external dependencies, compatible with embedded platforms.
+
+### Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│            ha_remotedevice (C SDK)              │
+│  Protocol Engine │ WS Frames │ JSON │ State     │
+│  Machine │ Transport Abstraction                │
+└──────────┬──────────────────────────────────────┘
+           │  Same C code, shared by device & app
+    ┌──────┴──────────────────┐
+    ▼                         ▼
+┌──────────────┐    ┌──────────────────────────┐
+│  ESP32 Bare   │    │  Linux App                │
+│  Pure C       │    │  (Python ctypes / Go CGo /│
+│  Simple Cmd   │    │   Node addon / C# P/Invoke)│
+└──────────────┘    └──────────────────────────┘
+```
+
+### Declarative API Design
+
+The device declares **what it is** and **what it can do** in code. The SDK handles all protocol details automatically:
+
+```c
+#include "ha_remotedevice.h"
+
+/* Declare capabilities */
+const char *caps[] = {"camera", "status", NULL};
+
+ha_config_t config = {
+    .transport = my_transport,     // User implements 4 functions
+    .server    = "192.168.1.100:9890",
+    .token     = "my-token",
+    .device = {
+        .device_id = "esp32-cam-1",
+        .name      = "Front Door Camera",
+        .kind      = "camera",
+        .caps      = caps,
+    },
+    .on_cmd    = my_cmd_handler,   // Called when receiving commands
+    .on_binary = my_data_handler,  // Called on binary data (TTS audio, etc.)
+    .on_state  = my_state_handler, // Connection state changes
+};
+
+ha_client_t *client = ha_client_new(&config);
+ha_client_start(client);
+while (1) {
+    ha_client_process(client);     // Main loop processing
+}
+```
+
+### Transport Layer Abstraction
+
+Users only need to implement 4 functions to adapt to different platforms:
+
+```c
+ha_transport_t my_transport = {
+    .connect = my_tcp_connect,   // Establish TCP connection
+    .send    = my_tcp_send,      // Send data
+    .recv    = my_tcp_recv,      // Receive data (blocking)
+    .close   = my_tcp_close,     // Close connection
+    .ctx     = &my_platform_ctx,
+};
+```
+
+### Protocol Support
+
+| Feature | API |
+|---------|-----|
+| WS connection + handshake | Automatic via `ha_client_start` |
+| Device registration (hello/bind) | Automatic on startup |
+| Command receive (shell/homeagent) | `on_cmd` callback |
+| Command result | `ha_client_send_result` |
+| Binary chunked transfer (video) | `ha_client_send_data_chunked` |
+| TTS audio receive | `on_binary` callback |
+| Event reporting | `ha_client_send_event` |
+| Status reporting | `ha_client_send_status` |
+| Heartbeat keepalive | Automatic ping/pong |
+
+### Usage
+
+Initialize a project via the `hmapdev` toolchain:
+
+```bash
+hmapdev init my-adapter --type remotedevice
+```
+
+Generates `main.c` + `CMakeLists.txt`, can be built directly or used as a third-party library:
+
+```cmake
+add_subdirectory(path/to/ha_remotedevice)
+target_link_libraries(my_app ha_remotedevice)
+target_include_directories(my_app PRIVATE ${HA_REMOTEDEVICE_INCLUDE_DIR})
+```
+
+### Quick Start Guide
+
+A complete step-by-step guide from zero to a device successfully connected to HomeAgent.
+
+#### Step 1: Preparation
+
+Create an access token on the HomeAgent platform:
+
+```bash
+# Create a device access token on the HomeAgent server
+curl -X POST http://<homeagent-server>:8080/api/v1/device/token \
+  -H "Content-Type: application/json" \
+  -d '{"device_id":"esp32-cam-1","name":"Front Door Camera","kind":"camera"}'
+# Returns: {"token":"ha-dev-token-xxxxx"}
+```
+
+Save the returned `token` — you'll need it in the device configuration.
+
+#### Step 2: Implement the Transport Layer (4 functions)
+
+Implement the 4 function pointers of `ha_transport_t` for your platform. Here are common scenarios:
+
+**Scenario A: Embedded device with TCP/IP stack (e.g., ESP32 + lwIP)**
+
+```c
+#include "ha_remotedevice.h"
+#include "lwip/sockets.h"
+
+static int esp_connect(void *ctx, const char *host, uint16_t port) {
+    struct sockaddr_in addr;
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) return -1;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    inet_pton(AF_INET, host, &addr.sin_addr);
+    int ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
+    if (ret < 0) { closesocket(sock); return -1; }
+    *(int *)ctx = sock;
+    return 0;
+}
+
+static int esp_send(void *ctx, const uint8_t *data, int len) {
+    int sock = *(int *)ctx;
+    return send(sock, (const char *)data, len, 0);
+}
+
+static int esp_recv(void *ctx, uint8_t *buf, int len) {
+    int sock = *(int *)ctx;
+    return recv(sock, (char *)buf, len, 0);
+}
+
+static void esp_close(void *ctx) {
+    int sock = *(int *)ctx;
+    closesocket(sock);
+}
+
+int esp_ctx = -1;
+ha_transport_t transport = {
+    .connect = esp_connect,
+    .send    = esp_send,
+    .recv    = esp_recv,
+    .close   = esp_close,
+    .ctx     = &esp_ctx,
+};
+```
+
+**Scenario B: Serial (UART) passthrough module**
+
+```c
+static int uart_connect(void *ctx, const char *host, uint16_t port) {
+    (void)host; (void)port;
+    return uart_init((uart_ctx_t *)ctx, 115200);
+}
+
+static int uart_send(void *ctx, const uint8_t *data, int len) {
+    return uart_write((uart_ctx_t *)ctx, data, len);
+}
+
+static int uart_recv(void *ctx, uint8_t *buf, int len) {
+    return uart_read((uart_ctx_t *)ctx, buf, len);
+}
+
+static void uart_close(void *ctx) {
+    uart_deinit((uart_ctx_t *)ctx);
+}
+```
+
+> Note: For UART passthrough, a TCP bridge program must run on the other end to forward serial data to the HomeAgent WebSocket port.
+
+#### Step 3: Declare Device Capabilities and Command Handlers
+
+```c
+#include "ha_remotedevice.h"
+
+/* Declare device capabilities */
+const char *caps[] = {"camera", "speaker", "status", NULL};
+
+/* Handle camerasue command (take photo) */
+static ha_status_t handle_camera(const char *req_id, const char *args,
+                                 ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    int duration = args[0] ? atoi(args) : 0;
+
+    // Capture image, fill the result
+    result->status = 0;
+    result->output = "data:image/jpeg;base64,/9j/4AAQ...";  // base64 image data
+    return HA_OK;
+}
+
+/* Handle shell command */
+static ha_status_t handle_shell(const char *req_id, const char *args,
+                                ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    result->status = 0;
+    result->output = "command executed";
+    return HA_OK;
+}
+
+/* Declarative command handler table */
+ha_cmd_handler_def_t handlers[] = {
+    {.command = "shell",      .handler = handle_shell},
+    {.command = "camerasue",  .handler = handle_camera},
+    {.command = "screensee",  .handler = handle_camera},
+    {.command = "speakeruse", .handler = handle_speaker},
+    {.command = NULL},  /* terminator */
+};
+```
+
+#### Step 4: Configure and Start the Client
+
+```c
+ha_config_t config = {
+    .transport = transport,                 // Transport layer implementation
+    .server    = "192.168.1.100:9890",      // HomeAgent server address
+    .token     = "ha-dev-token-xxxxx",      // Token from Step 1
+    .device = {
+        .device_id = "esp32-cam-1",
+        .name      = "Front Door Camera",
+        .kind      = "camera",
+        .caps      = caps,
+        .info_json = "{\"chip\":\"ESP32-S3\",\"firmware\":\"v1.0\"}",
+    },
+    .handlers  = handlers,                  // Command handler table
+    .on_binary = on_binary_data,            // Receive TTS audio etc.
+    .on_state  = on_state_change,           // Connection state callback
+    .ping_interval = 30,
+};
+
+ha_client_t *client = ha_client_new(&config);
+ha_status_t ret = ha_client_start(client);
+if (ret != HA_OK) {
+    printf("Device connection failed: %d\n", ret);
+    return;
+}
+
+/* Main loop */
+while (1) {
+    ha_client_process(client);  // Process protocol frames, heartbeats, commands
+
+    /* Optional: device-initiated event reporting */
+    ha_client_send_event(client, "motion_detected",
+                         "{\"zone\":\"front_door\",\"confidence\":0.95}");
+
+    /* Optional: report device status */
+    ha_client_send_status(client, "online");
+
+    vTaskDelay(100 / portTICK_PERIOD_MS);  // RTOS-style delay
+}
+```
+
+#### Step 5: Verify the Connection
+
+Check if the device is online on the HomeAgent server:
+
+```bash
+# List registered devices
+curl http://<homeagent-server>:8080/api/v1/device/list
+# Expected output includes: {"device_id":"esp32-cam-1","status":"online",...}
+
+# Send a command to the device (test camerasue)
+curl -X POST http://<homeagent-server>:8080/api/v1/device/esp32-cam-1/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"cmd":"camerasue","args":"3"}'
+# Expected: {"status":"ok","result":"data:image/jpeg;base64,..."}
+```
+
+#### Step 6: Debugging Tips
+
+| Issue | Check |
+|-------|-------|
+| Connection failed | Verify `server` address and port are reachable; check `token` |
+| WS handshake failed | Verify HomeAgent server WebSocket support is enabled |
+| Command not responding | Confirm the command name is registered in `handlers` table; check `on_binary` |
+| Reconnection issues | `max_reconnect` controls retry count; -1 = infinite |
+| Low memory (embedded) | Define `HA_NO_ALLOC` to disable dynamic memory allocation |
+
+### Location
+
+- **SDK Source**: `remotedevice/`
+- **hmapdev template**: `hmapdev init --type remotedevice`
+
 ## Building & Installing
 
 ### Build
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
-Outputs a `.hmap` package to the `dist/` directory (default is the multi-platform bundle; use `plugindev build --no-bundle` for a single-target build).
+Outputs a `.hmap` package to the `dist/` directory (default is the multi-platform bundle; use `hmapdev build --no-bundle` for a single-target build).
 
 ### Install
 
@@ -291,3 +813,19 @@ curl -X POST http://127.0.0.1:9876/plugins \
 ```
 
 Or upload via the WebUI plugin management page, or manually place the `.hmap` in the plugin directory and restart the platform.
+
+## License
+
+The SDK is released under **AGPL-3.0-only** — see [LICENSE](LICENSE).
+
+**This is a substantive constraint for plugin developers**: the SDK is **statically linked** into
+your plugin (its source ends up in the plugin binary), so the plugin is a derivative work of
+this SDK and **must be released under the same license**. Because AGPL §13 covers network
+interaction, a plugin that serves users over HTTP/WebSocket must also offer them the source.
+If you need a closed-source plugin, the only compliant route is a separate exception/commercial
+license from this project — none is offered today.
+
+Third-party components (Go dependencies: go-sqlite3, gojieba, bubbletea, … — MIT / BSD-3 /
+Apache-2.0) keep their own licenses. The platform-side model and inference runtime
+(Chinese-CLIP Apache-2.0, ONNX Runtime MIT) are not part of this SDK; their full license texts
+ship with the release packages under `/usr/share/doc/homeagent/licenses/`.

example/a2a/plg.json

@@ -2,14 +2,18 @@
   "name": "a2a",
   "name_zh": "A2A 代理通信",
   "name_en": "A2A Agent Communication",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Agent-to-Agent 协议通信插件，支持双向 A2A 通信：可查询其他 Agent 并回复其请求。提供 HTTP 服务端暴露本 Agent 能力。",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["a2a", "agent", "interop"],
+  "tags": [
+    "a2a",
+    "agent",
+    "interop"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/a2a/plugin.go

@@ -21,15 +21,47 @@ type Plugin struct {
 	srvMu      sync.Mutex
 	server     *http.Server
 	serverAddr string
+
+	// 会话表：session_id → 上下文前缀。A2A 无状态协议下由插件侧维护
+	// 多轮上下文：同 session 的后续请求会把之前的对话拼进注入文本。
+	sessMu    sync.Mutex
+	sessions  map[string]*a2aSession
 }
 
+// a2aSession 记录一个会话的轮次历史，用于延续上下文。
+type a2aSession struct {
+	ID       string
+	History  []string // 轮次文本 [user1, agent1, user2, agent2, ...]
+	LastUsed time.Time
+}
+
+// maxSessionTurns 单会话保留的最大轮次对数（防上下文无限膨胀）。
+const maxSessionTurns = 10
+
+// sessionGCPeriod 会话过期清理周期；超过 2 小时未用的会话回收。
+const sessionGCPeriod = 30 * time.Minute
+
 func (p *Plugin) Name() string { return p.name }
 
 func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	s.SetAutoRestart(true)
 	p.sdk = s
+	p.sessions = make(map[string]*a2aSession)
 	tp := p.name + "_"
 
+	// 注册自身为输出通道：agent 回复 emit 到本通道时有落点，
+	// 且 output_list_channels 可见（agent 能主动向 a2a 会话推送消息）。
+	if err := s.RegisterOutputChannel(p.name, 1, "A2A Agent 互联通道（外部 agent 查询的回复由此返回）", sdk.ChannelDef{}, func(args map[string]interface{}) (interface{}, error) {
+		payload, _ := args["payload"].(string)
+		log.Printf("[%s] channel output: %s", p.name, truncateRunes(payload, 120))
+		return map[string]interface{}{"status": "ok"}, nil
+	}); err != nil {
+		log.Printf("[%s] register output channel: %v", p.name, err)
+	}
+
+	// 会话 GC：后台周期回收长期不用的会话
+	go p.sessionGCLoop()
+
 	s.Settings().RegisterDef(sdk.ConfigDef{
 		Key: "listen", Default: "127.0.0.1:12000",
 		Type: "string", DisplayName: "监听地址",
@@ -45,6 +77,7 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 			"properties": map[string]interface{}{
 				"agent_url": map[string]interface{}{"type": "string", "description": "目标 Agent 的 A2A 端点 URL"},
 				"query":     map[string]interface{}{"type": "string", "description": "发送给目标 Agent 的文本查询"},
+				"session_id": map[string]interface{}{"type": "string", "description": "可选。上次调用返回的 session_id，传入可延续与该 agent 的多轮对话上下文"},
 				"timeout":   map[string]interface{}{"type": "integer", "description": "超时时间（秒），默认 60"},
 			},
 			"required": []string{"agent_url", "query"},
@@ -114,6 +147,66 @@ func (p *Plugin) Stop() error {
 	return nil
 }
 
+// sessionGCLoop 周期清理超时会话。
+func (p *Plugin) sessionGCLoop() {
+	ticker := time.NewTicker(sessionGCPeriod)
+	defer ticker.Stop()
+	for range ticker.C {
+		p.sessMu.Lock()
+		for id, sess := range p.sessions {
+			if time.Since(sess.LastUsed) > 2*time.Hour {
+				delete(p.sessions, id)
+			}
+		}
+		p.sessMu.Unlock()
+	}
+}
+
+func truncateRunes(s string, n int) string {
+	r := []rune(s)
+	if len(r) <= n {
+		return s
+	}
+	return string(r[:n]) + "..."
+}
+
+// sessionMessages 返回指定会话的近 limit 条消息（时间正序），
+// 会话不存在返回 nil。消息格式 [{role, text, ts}]。
+func (p *Plugin) sessionMessages(sessionID string, limit int) []map[string]interface{} {
+	p.sessMu.Lock()
+	sess := p.sessions[sessionID]
+	var hist []string
+	var lastUsed time.Time
+	if sess != nil {
+		hist = append([]string{}, sess.History...)
+		lastUsed = sess.LastUsed
+	}
+	p.sessMu.Unlock()
+	if sess == nil {
+		return nil
+	}
+	_ = lastUsed
+	// History 交替 [user, agent, user, agent...]，取末尾 limit 条，保持时间正序
+	start := 0
+	if len(hist) > limit {
+		start = len(hist) - limit
+	}
+	msgs := make([]map[string]interface{}, 0, len(hist)-start)
+	for i := start; i < len(hist); i++ {
+		role, text := "user", hist[i]
+		if after, ok := strings.CutPrefix(text, "用户: "); ok {
+			role, text = "user", after
+		} else if after, ok := strings.CutPrefix(text, "助手: "); ok {
+			role, text = "agent", after
+		}
+		msgs = append(msgs, map[string]interface{}{
+			"role": role,
+			"text": text,
+		})
+	}
+	return msgs
+}
+
 func (p *Plugin) stopServer() {
 	p.srvMu.Lock()
 	defer p.srvMu.Unlock()
@@ -137,7 +230,12 @@ func (p *Plugin) startServer(addr string) error {
 		return fmt.Errorf("listen %s: %v", addr, err)
 	}
 
-	srv := &http.Server{Handler: mux}
+	srv := &http.Server{
+		Handler:      mux,
+		ReadTimeout:  30 * time.Second,
+		WriteTimeout: 120 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
 	addrStr := listener.Addr().String()
 
 	p.srvMu.Lock()
@@ -186,7 +284,9 @@ func (p *Plugin) handleIncomingA2A(w http.ResponseWriter, r *http.Request) {
 		ID      string `json:"id"`
 		Method  string `json:"method"`
 		Params  struct {
-			Query   string `json:"query,omitempty"`
+			Query     string `json:"query,omitempty"`
+			SessionID string `json:"session_id,omitempty"`
+			Limit     int    `json:"limit,omitempty"`
 			Message *struct {
 				Role  string `json:"role"`
 				Parts []struct {
@@ -210,29 +310,96 @@ func (p *Plugin) handleIncomingA2A(w http.ResponseWriter, r *http.Request) {
 			}
 			queryText = strings.TrimSpace(queryText)
 		}
-
-		// Inject into agent pipeline via interrupt (preempt current processing) or direct input
-		if queryText != "" {
-			p.sdk.InjectInterruptText("a2a", "webui", fmt.Sprintf("[来自A2A Agent的查询]\n%s", queryText))
+		if queryText == "" {
+			http.Error(w, "query/message.text required", http.StatusBadRequest)
+			return
 		}
 
-		// Respond with task accepted
+		// 会话：调用方可指定 session_id 延续多轮上下文；不指定则新建。
+		sessionID := strings.TrimSpace(req.Params.SessionID)
+		injectText := queryText
+		p.sessMu.Lock()
+		if sessionID != "" {
+			sess := p.sessions[sessionID]
+			if sess == nil {
+				sess = &a2aSession{ID: sessionID, LastUsed: time.Now()}
+				p.sessions[sessionID] = sess
+			}
+			sess.LastUsed = time.Now()
+			// 有历史则把上下文拼在前面（截尾防爆量）
+			if len(sess.History) > 0 {
+				ctxText := strings.Join(sess.History, "\n")
+				injectText = "[对话上下文]\n" + ctxText + "\n[本轮输入]\n" + queryText
+			}
+		} else {
+			sessionID = fmt.Sprintf("a2a_%d", time.Now().UnixNano())
+			p.sessions[sessionID] = &a2aSession{ID: sessionID, LastUsed: time.Now()}
+		}
+		p.sessMu.Unlock()
+
+		// 同步注入：阻塞等待 agent 处理完成拿回复（不再抢占打断、
+		// 也不再回 202 让请求方永远等不到结果）。HTTP 超时由调用方控制。
+		reply := p.sdk.InjectInputSync(p.name, p.name,
+			fmt.Sprintf("[来自A2A Agent的查询 session=%s]\n%s\n[注意] 请直接以文本回复本查询，不要调用 output_send__%s——你的最终文本回复会被系统自动返回给请求方。", sessionID, injectText, p.name))
+
+		// 回复写回会话历史（下一轮作为上下文）
+		p.sessMu.Lock()
+		if sess := p.sessions[sessionID]; sess != nil {
+			sess.History = append(sess.History, "用户: "+queryText, "助手: "+reply)
+			if len(sess.History) > maxSessionTurns*2 {
+				sess.History = sess.History[len(sess.History)-maxSessionTurns*2 :]
+			}
+			sess.LastUsed = time.Now()
+		}
+		p.sessMu.Unlock()
+
 		resp := map[string]interface{}{
 			"jsonrpc": "2.0",
 			"id":      req.ID,
 			"result": map[string]interface{}{
 				"id":     fmt.Sprintf("task_%d", time.Now().UnixNano()),
-				"status": "submitted",
+				"status": "completed",
+				"session_id": sessionID,
+				"message": map[string]interface{}{
+					"role": "agent",
+					"parts": []map[string]string{{"type": "text", "text": reply}},
+				},
 			},
 		}
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(resp)
 
-	case "tasks.get":
+	case "tasks.get", "session.get":
+		// 按 session_id 返回会话内近 N 条消息（默认 10 条）。
+		sessionID := strings.TrimSpace(req.Params.SessionID)
+		if sessionID == "" {
+			sessionID = strings.TrimSpace(req.Params.Query)
+		}
+		limit := 10
+		if req.Params.Limit > 0 && req.Params.Limit <= 100 {
+			limit = req.Params.Limit
+		}
+		msgs := p.sessionMessages(sessionID, limit)
+		if msgs == nil {
+			w.Header().Set("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"jsonrpc": "2.0", "id": req.ID,
+				"result": map[string]interface{}{
+					"session_id": sessionID,
+					"status":     "not_found",
+					"messages":   []interface{}{},
+				},
+			})
+			return
+		}
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]interface{}{
 			"jsonrpc": "2.0", "id": req.ID,
-			"result": map[string]interface{}{"id": req.Params.Query, "status": "unknown"},
+			"result": map[string]interface{}{
+				"session_id": sessionID,
+				"status":     "completed",
+				"messages":   msgs,
+			},
 		})
 
 	default:
@@ -276,9 +443,10 @@ type A2ARequest struct {
 }
 
 type A2AParams struct {
-	Query   string      `json:"query,omitempty"`
-	Message *A2AMessage `json:"message,omitempty"`
-	TaskID  string      `json:"id,omitempty"`
+	Query     string      `json:"query,omitempty"`
+	SessionID string      `json:"session_id,omitempty"`
+	Message   *A2AMessage `json:"message,omitempty"`
+	TaskID    string      `json:"id,omitempty"`
 }
 
 type A2AResponse struct {
@@ -291,6 +459,7 @@ type A2AResponse struct {
 type A2AResult struct {
 	TaskID    string       `json:"id,omitempty"`
 	Status    string       `json:"status,omitempty"`
+	SessionID string       `json:"session_id,omitempty"`
 	Message   *A2AMessage  `json:"message,omitempty"`
 	AgentCard *A2AAgentCard `json:"agent_card,omitempty"`
 }
@@ -356,6 +525,7 @@ func (p *Plugin) handleA2ADiscover(args map[string]interface{}) (interface{}, er
 func (p *Plugin) handleA2AQuery(args map[string]interface{}) (interface{}, error) {
 	agentURL, _ := args["agent_url"].(string)
 	query, _ := args["query"].(string)
+	sessionID, _ := args["session_id"].(string) // 可选：延续对方会话
 	timeoutSec := 60
 	if v, ok := args["timeout"].(float64); ok && v > 0 {
 		timeoutSec = int(v)
@@ -377,7 +547,8 @@ func (p *Plugin) handleA2AQuery(args map[string]interface{}) (interface{}, error
 		ID:      fmt.Sprintf("a2a_%d", time.Now().UnixNano()),
 		Method:  "tasks.send",
 		Params: A2AParams{
-			Message: &A2AMessage{Role: "user", Parts: []A2APart{{Text: query, Type: "text"}}},
+			SessionID: sessionID,
+			Message:   &A2AMessage{Role: "user", Parts: []A2APart{{Text: query, Type: "text"}}},
 		},
 	}
 
@@ -416,10 +587,18 @@ func (p *Plugin) handleA2AQuery(args map[string]interface{}) (interface{}, error
 		replyText = strings.TrimSpace(replyText)
 	}
 
-	return map[string]interface{}{
+	result := map[string]interface{}{
 		"task_id": a2aResp.Result.TaskID, "status": a2aResp.Result.Status,
 		"response": replyText,
-	}, nil
+	}
+	if a2aResp.Result.SessionID != "" || sessionID != "" {
+		result["session_id"] = a2aResp.Result.SessionID
+		if result["session_id"] == "" {
+			result["session_id"] = sessionID
+		}
+		result["note"] = "延续会话：下次调用传此 session_id 可保持上下文"
+	}
+	return result, nil
 }
 
 // ---- Management Handlers ----

example/acp/plg.json

@@ -2,11 +2,15 @@
   "name": "acp",
   "name_zh": "ACP 代理通信",
   "name_en": "ACP Agent Client Protocol",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Agent Client Protocol 通信插件：充当 ACP 服务端接受其他 Agent 的任务请求，同时提供客户端工具向远程 ACP Agent（如 opencode）发起会话并读取回复",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["acp", "agent", "interop"],
+  "tags": [
+    "acp",
+    "agent",
+    "interop"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,

example/acp/plugin.go

@@ -34,8 +34,13 @@ type Plugin struct {
 type sessionState struct {
 	ID       string
 	Replying []map[string]interface{}
+	History  []string // 轮次历史 [user, agent, user, agent...]，延续上下文用
+	LastUsed time.Time
 }
 
+// maxSessionTurns 单会话保留的最大轮次对数。
+const maxSessionTurns = 10
+
 func (p *Plugin) Name() string { return p.name }
 
 func (p *Plugin) Start(s *sdk.PluginSDK) error {
@@ -44,6 +49,14 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	p.sessions = make(map[string]*sessionState)
 	tp := p.name + "_"
 
+	// 注册自身为输出通道：agent 回复 emit 到本通道时有落点。
+	// （回复主要走同步注入返回，此通道用于 agent 主动 output_send__acp）
+	s.RegisterOutputChannel(p.name, 1, "ACP Agent 互联通道（外部 agent 会话的回复由此返回）", sdk.ChannelDef{}, func(args map[string]interface{}) (interface{}, error) {
+		payload, _ := args["payload"].(string)
+		log.Printf("[%s] channel output: %s", p.name, truncateStr(payload, 120))
+		return map[string]interface{}{"status": "ok"}, nil
+	})
+
 	s.Settings().RegisterDef(sdk.ConfigDef{
 		Key: "listen", Default: "127.0.0.1:12001",
 		Type: "string", DisplayName: "监听地址",
@@ -58,6 +71,7 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 			"properties": map[string]interface{}{
 				"server_url": map[string]interface{}{"type": "string", "description": "目标 ACP 服务端地址（如 http://127.0.0.1:13000）"},
 				"prompt":     map[string]interface{}{"type": "string", "description": "发送给目标 Agent 的任务描述"},
+				"session_id": map[string]interface{}{"type": "string", "description": "可选。上次调用返回的 session_id，传入可延续与该 agent 的多轮对话上下文"},
 				"timeout":    map[string]interface{}{"type": "integer", "description": "等待回复超时（秒），默认 120"},
 			},
 			"required": []string{"server_url", "prompt"},
@@ -171,6 +185,7 @@ func (p *Plugin) handleSessionPost(w http.ResponseWriter, r *http.Request) {
 				Text string `json:"text"`
 			} `json:"request,omitempty"`
 			SessionID string `json:"session_id,omitempty"`
+			Limit     int    `json:"limit,omitempty"`
 			Final     bool   `json:"final,omitempty"`
 		} `json:"params,omitempty"`
 	}
@@ -190,21 +205,109 @@ func (p *Plugin) handleSessionPost(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		sid := fmt.Sprintf("session_%d", time.Now().UnixNano())
+		// 会话：调用方可指定 session_id 延续多轮；不指定则新建。
+		sid := strings.TrimSpace(req.Params.SessionID)
 		p.mu.Lock()
-		p.sessions[sid] = &sessionState{ID: sid}
+		if sid != "" {
+			if _, exists := p.sessions[sid]; !exists {
+				p.sessions[sid] = &sessionState{ID: sid, LastUsed: time.Now()}
+			}
+		} else {
+			sid = fmt.Sprintf("session_%d", time.Now().UnixNano())
+			p.sessions[sid] = &sessionState{ID: sid, LastUsed: time.Now()}
+		}
+		st := p.sessions[sid]
 		p.mu.Unlock()
 
-		if p.sdk != nil {
-			p.sdk.InjectInterruptText(p.name, "acp",
-				fmt.Sprintf("[来自ACP Agent的请求请求 session %s]\n%s", sid, text))
+		// 延续上下文
+		injectText := text
+		p.mu.Lock()
+		if len(st.History) > 0 {
+			ctxText := strings.Join(st.History, "\n")
+			injectText = "[对话上下文]\n" + ctxText + "\n[本轮输入]\n" + text
 		}
+		p.mu.Unlock()
+
+		// 同步注入等待回复：不抢占打断，完整闭环返回文本。
+		reply := ""
+		if p.sdk != nil {
+			reply = p.sdk.InjectInputSync(p.name, p.name,
+				fmt.Sprintf("[来自ACP Agent的请求 session %s]\n%s\n[注意] 请直接以文本回复本请求，不要调用 output_send__%s——你的最终文本回复会被系统自动返回给请求方。", sid, injectText, p.name))
+		}
+
+		// 写回历史 + 填充 Replying 供 SSE 消费
+		p.mu.Lock()
+		st.History = append(st.History, "用户: "+text, "助手: "+reply)
+		if len(st.History) > maxSessionTurns*2 {
+			st.History = st.History[len(st.History)-maxSessionTurns*2:]
+		}
+		st.LastUsed = time.Now()
+		if reply != "" {
+			st.Replying = append(st.Replying, map[string]interface{}{
+				"type": "reply", "text": reply,
+			})
+		}
+		p.mu.Unlock()
 
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]interface{}{
 			"jsonrpc": "2.0", "id": req.ID,
 			"result": map[string]interface{}{
 				"session": map[string]interface{}{"id": sid},
+				"reply":   reply,
+			},
+		})
+
+	case "session/get":
+		// 按 session_id 返回会话内近 N 条消息（默认 10 条，时间正序）
+		sid := req.Params.SessionID
+		p.mu.RLock()
+		st := p.sessions[sid]
+		var hist []string
+		if st != nil {
+			hist = append([]string{}, st.History...)
+		}
+		p.mu.RUnlock()
+		if st == nil {
+			w.Header().Set("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"jsonrpc": "2.0", "id": req.ID,
+				"result": map[string]interface{}{
+					"session_id": sid,
+					"status":     "not_found",
+					"messages":   []interface{}{},
+				},
+			})
+			return
+		}
+		limit := 10
+		if req.Params.Limit > 0 && req.Params.Limit <= 100 {
+			limit = req.Params.Limit
+		}
+		start := 0
+		if len(hist) > limit {
+			start = len(hist) - limit
+		}
+		msgs := make([]map[string]interface{}, 0, len(hist)-start)
+		for i := start; i < len(hist); i++ {
+			role, text := "user", hist[i]
+			if after, ok := strings.CutPrefix(text, "用户: "); ok {
+				role, text = "user", after
+			} else if after, ok := strings.CutPrefix(text, "助手: "); ok {
+				role, text = "agent", after
+			}
+			msgs = append(msgs, map[string]interface{}{
+				"role": role,
+				"text": text,
+			})
+		}
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"jsonrpc": "2.0", "id": req.ID,
+			"result": map[string]interface{}{
+				"session_id": sid,
+				"status":     "completed",
+				"messages":   msgs,
 			},
 		})
 
@@ -212,12 +315,17 @@ func (p *Plugin) handleSessionPost(w http.ResponseWriter, r *http.Request) {
 		sid := req.Params.SessionID
 		p.mu.Lock()
 		st := p.sessions[sid]
-		if st != nil && req.Params.Final {
-			st.Replying = append(st.Replying, map[string]interface{}{
-				"type": "reply", "text": "done",
-			})
-		}
 		p.mu.Unlock()
+		if st == nil {
+			http.Error(w, "session not found", http.StatusNotFound)
+			return
+		}
+		if req.Params.Final {
+			// 客户端结束会话：标记并保留历史（后续可再 session/new 续）
+			p.mu.Lock()
+			st.LastUsed = time.Now()
+			p.mu.Unlock()
+		}
 
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]interface{}{
@@ -338,6 +446,7 @@ func (p *Plugin) handleAcpQuery(args map[string]interface{}) (interface{}, error
 	if prompt == "" {
 		return map[string]interface{}{"error": "prompt 不能为空"}, nil
 	}
+	sessionID, _ := args["session_id"].(string) // 可选：延续对方会话
 	timeoutSec := 120
 	if v, ok := args["timeout"].(float64); ok && v > 0 {
 		timeoutSec = int(v)
@@ -346,12 +455,16 @@ func (p *Plugin) handleAcpQuery(args map[string]interface{}) (interface{}, error
 	endpoint := serverURL + "/api/session"
 	client := &http.Client{Timeout: time.Duration(timeoutSec) * time.Second}
 
+	params := map[string]interface{}{
+		"request": map[string]interface{}{"text": prompt},
+	}
+	if sessionID != "" {
+		params["session_id"] = sessionID
+	}
 	newBody, _ := json.Marshal(map[string]interface{}{
 		"jsonrpc": "2.0", "id": "acp-" + fmt.Sprintf("%d", time.Now().UnixNano()),
 		"method": "session/new",
-		"params": map[string]interface{}{
-			"request": map[string]interface{}{"text": prompt},
-		},
+		"params": params,
 	})
 
 	req, _ := http.NewRequest("POST", endpoint, bytes.NewReader(newBody))
@@ -416,6 +529,7 @@ func (p *Plugin) handleAcpQuery(args map[string]interface{}) (interface{}, error
 		"session_id": sid,
 		"status":     "completed",
 		"reply":      replyText,
+		"note":       "延续会话：下次调用传此 session_id 可保持上下文",
 	}, nil
 }
 

example/ai_image/README.md

@@ -5,7 +5,7 @@ ai_image plugin
 ## Build
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
 ## Install

example/ai_image/plg.json

@@ -2,14 +2,19 @@
   "name": "ai_image",
   "name_zh": "AI绘图",
   "name_en": "AI Image",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "AI 图像生成插件，支持 OpenAI DALL·E / Stable Diffusion",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["ai", "image", "draw", "generate"],
+  "tags": [
+    "ai",
+    "image",
+    "draw",
+    "generate"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/ai_image/plugin.go

@@ -5,7 +5,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
+	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -21,6 +24,8 @@ type Plugin struct {
 	provider string
 	model   string
 	size    string
+	baseURL string
+	dataDir string // <data>/ai_images：生成本地图片存放目录
 }
 
 func NewPluginFactory(name string, config map[string]interface{}) (sdk.Plugin, error) {
@@ -111,10 +116,15 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 		DisplayName: "API Key", Description: "OpenAI / Stable Diffusion API Key",
 		Category: "ai_image", Secret: true,
 	})
+	s.Settings().RegisterDef(sdk.ConfigDef{
+		Key: "base_url", Default: "", Type: "string",
+		DisplayName: "Base URL", Description: "自定义 OpenAI 兼容网关地址（不带 /v1 尾缀，如 http://127.0.0.1:8081）；为空走官方 https://api.openai.com",
+		Category:    "ai_image",
+	})
 	s.Settings().RegisterDef(sdk.ConfigDef{
 		Key: "provider", Default: "openai", Type: "string",
 		DisplayName: "Provider", Description: "Image generation provider: openai / stability",
-		Category: "ai_image",
+		Category:    "ai_image",
 	})
 	s.Settings().RegisterDef(sdk.ConfigDef{
 		Key: "model", Default: "dall-e-3", Type: "string",
@@ -131,10 +141,23 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	p.provider = getSetting(s.Settings(), "provider", "openai")
 	p.model = getSetting(s.Settings(), "model", "dall-e-3")
 	p.size = getSetting(s.Settings(), "size", "1024x1024")
+	p.baseURL = strings.TrimRight(strings.TrimSpace(getSetting(s.Settings(), "base_url", "")), "/")
+
+// 生图本地存放目录：插件专属数据目录（SDK DataDir API，内核保证存在）。
+if p.sdk != nil {
+	if dd := s.Settings().DataDir(); dd != "" {
+		p.dataDir = dd
+	}
+}
+if p.dataDir == "" {
+	// 旧版内核无 DataDir API 时退到 /tmp
+	p.dataDir = filepath.Join(os.TempDir(), "homeagent_ai_images")
+}
+os.MkdirAll(p.dataDir, 0755)
 
 	tp := p.name + "_"
 	s.RegisterTool(tp+"generate", sdk.ToolDef{
-		Name: tp + "generate", Description: "Generate image from text prompt using AI. Returns image URL.",
+		Name: tp + "generate", Description: "Generate image from text prompt using AI. Downloads the result locally and returns a local file path (permanent, no expiry). To show the user, send it via output_send with type=image and payload=the returned path.",
 		Parameters: map[string]interface{}{
 			"type": "object",
 			"properties": map[string]interface{}{
@@ -209,6 +232,14 @@ func (p *Plugin) handleGenerate(args map[string]interface{}) (interface{}, error
 }
 
 func (p *Plugin) generateOpenAI(prompt, model, size string, n int, apiKey string) (interface{}, error) {
+	// 上游地址：base_url 非空时走自定义网关（如本机 llmsproxy），约定不带 /v1 尾缀；
+	// 为空保持官方直连。兼容误配了 /v1 尾缀的情况（去重）。
+	endpoint := "https://api.openai.com/v1/images/generations"
+	if p.baseURL != "" {
+		base := strings.TrimSuffix(p.baseURL, "/v1")
+		endpoint = base + "/v1/images/generations"
+	}
+
 	body := openAIReq{
 		Model:          model,
 		Prompt:         prompt,
@@ -217,8 +248,9 @@ func (p *Plugin) generateOpenAI(prompt, model, size string, n int, apiKey string
 		ResponseFormat: "url",
 	}
 
+	log.Printf("[ai_image] endpoint=%s baseURL=%q model=%q", endpoint, p.baseURL, model)
 	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("POST", "https://api.openai.com/v1/images/generations", bytes.NewReader(b))
+	req, _ := http.NewRequest("POST", endpoint, bytes.NewReader(b))
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", "Bearer "+apiKey)
 
@@ -247,14 +279,74 @@ func (p *Plugin) generateOpenAI(prompt, model, size string, n int, apiKey string
 		urls[i] = d.URL
 	}
 
+	// 下载到本地 data 目录，返回本地文件路径（而非临时 S3 URL）：
+	// - S3 临时 URL 约 1 小时过期，且对无浏览器 UA 的客户端拒绝访问
+	// - 本地路径可经 webui /files/ 永久下发给所有客户端（含 API key 客户端）
+	localPaths := make([]string, len(urls))
+	var errs []string
+	for i, u := range urls {
+		path, err := p.downloadImage(u, fmt.Sprintf("ai_%s_%d", model, time.Now().UnixNano()))
+		if err != nil {
+			errs = append(errs, fmt.Sprintf("第%d张下载失败: %v", i+1, err))
+			continue
+		}
+		localPaths[i] = path
+	}
+
+	content := fmt.Sprintf("Generated %d image(s) with model %s:", len(urls), model)
+	for _, pth := range localPaths {
+		if pth != "" {
+			content += "\n" + pth
+		}
+	}
+	if len(errs) > 0 {
+		content += "\n\n" + strings.Join(errs, "\n")
+	}
+	content += "\n\n已将图片保存到本地（不会过期）。如需展示请用 output_send__webui(payload=本地路径, type=image)。"
 	return map[string]interface{}{
-		"content": fmt.Sprintf("Generated %d image(s) with model %s:\n%s", len(urls), model, strings.Join(urls, "\n")),
-		"images":  urls,
-		"prompt":  prompt,
-		"model":   model,
+		"content":     content,
+		"images":      localPaths,
+		"prompt":      prompt,
+		"model":       model,
+		"local_paths": localPaths,
 	}, nil
 }
 
+// downloadImage 把生图返回的临时 URL 下载为本地文件，返回本地路径。
+// 带浏览器 UA 以规避图床对无 UA 客户端的拦截。
+func (p *Plugin) downloadImage(url, baseName string) (string, error) {
+	dl := &http.Client{Timeout: 60 * time.Second}
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; HomeAgent/1.0)")
+	resp, err := dl.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		b, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(b))[:200])
+	}
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	ext := ".png"
+	if ct := resp.Header.Get("Content-Type"); strings.Contains(ct, "jpeg") || strings.Contains(ct, "jpg") {
+		ext = ".jpg"
+	} else if strings.Contains(ct, "webp") {
+		ext = ".webp"
+	}
+	path := filepath.Join(p.dataDir, baseName+ext)
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return "", err
+	}
+	return path, nil
+}
+
 type stabilityReq struct {
 	TextPrompts []stabilityPrompt `json:"text_prompts"`
 	Width       int               `json:"width"`
@@ -334,7 +426,7 @@ func (p *Plugin) generateStability(prompt, model, size string, n int, apiKey str
 	}
 
 	return map[string]interface{}{
-		"content": fmt.Sprintf("Generated %d image(s) via Stability AI:\n%s", len(urls), strings.Join(urls, "\n")),
+		"content": fmt.Sprintf("Generated %d image(s) via Stability AI:\n%s\n\n图片已保存到本地，如需展示请用 output_send(type=image)。", len(urls), strings.Join(urls, "\n")),
 		"images":  urls,
 		"prompt":  prompt,
 		"model":   model,

example/bili/plg.json

@@ -2,14 +2,18 @@
   "name": "bili",
   "name_zh": "B站视频下载",
   "name_en": "Bilibili Video Downloader",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "B站视频下载工具，基于 yt-dlp 引擎。支持查看视频清晰度列表、指定格式下载、可配置下载目录。",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["bili", "video", "download"],
+  "tags": [
+    "bili",
+    "video",
+    "download"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/bili/plugin.go

@@ -107,6 +107,14 @@ func (p *Plugin) handleBiliVideo(args map[string]interface{}) (interface{}, erro
 			}
 		}
 	}
+	// 安全校验：output_dir 是配置项，但避免被配成系统目录导致 yt-dlp 任意位置写。
+	// 禁止根/家目录本身，且规范化后必须落在明确子目录内。
+	outputDir = filepath.Clean(outputDir)
+	for _, forbidden := range []string{"/", "/etc", "/usr", "/bin", "/sbin", "/boot", "/dev", "/proc", "/sys", "/var"} {
+		if outputDir == forbidden {
+			return nil, fmt.Errorf("output_dir 不能是系统目录 %s", forbidden)
+		}
+	}
 	os.MkdirAll(outputDir, 0755)
 
 	var out bytes.Buffer

example/browser/plg.json

@@ -2,14 +2,20 @@
   "name": "browser",
   "name_zh": "浏览器",
   "name_en": "Browser",
-  "version": "2.0.0",
+  "version": "2.3.0",
   "description": "统一浏览器插件：搜索、HTTP抓取(quick)、无头渲染(normal)、交互式浏览器(interactive/CDP)",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["web", "search", "fetch", "browser", "cdp"],
+  "tags": [
+    "web",
+    "search",
+    "fetch",
+    "browser",
+    "cdp"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/browser/plugin.go

@@ -13,6 +13,7 @@ import (
 	"net/url"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -33,23 +34,49 @@ type Plugin struct {
 	proxy   string
 	client  *http.Client
 
-	sessions map[string]*BrowserSession
-	nextID   int
-	wg       sync.WaitGroup
-	stopCh   chan struct{}
-	stopOnce sync.Once
+	sessions    map[string]*BrowserSession
+	nextID      int
+	wg          sync.WaitGroup
+	stopCh      chan struct{}
+	stopOnce    sync.Once
+	profilesDir string // 持久化 profile 根目录（<data>/browser_profiles），空则禁用
+
+	// 共享浏览器单例：所有 agent 共用一个 Chromium 进程（全局 UserDataDir，
+	// 登录态/cookies 跨 agent、跨会话、跨插件重启保留），每个 start 创建一个
+	// 新标签页（CDP Target）。同 source 复用自己的标签页。浏览器进程在
+	// 最后一个标签页关闭后保留（避免反复冷启动），仅插件 Stop 时回收。
+	sharedAllocCtx  context.Context
+	sharedAllocCancel context.CancelFunc
+	sharedMu        sync.Mutex
 }
 
 type BrowserSession struct {
 	id        string
-	allocCtx  context.Context
+	allocCtx  context.Context // 共享浏览器进程上下文（shared=true 时指向全局单例）
 	cancel    context.CancelFunc
-	ctx       context.Context
+	ctx       context.Context // 本会话的 Target 上下文（一个标签页）
 	createdAt time.Time
 	timeout   time.Duration
 	closed    bool
 	mu        sync.Mutex
 	currentURL string
+	shared     bool   // true=共享浏览器的一个标签页；false=独占浏览器实例
+	profileDir string // 非空表示使用持久化 profile（关闭时不删目录）
+	sessionKey string // 共享模式下的复用键（agent 来源标识，同 key 复用同一标签页）
+}
+
+// sanitizeProfileName 消毒 profile 名：仅保留字母数字-_，防路径穿越。
+func sanitizeProfileName(name string) string {
+	var b []byte
+	for _, c := range []byte(name) {
+		if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_' {
+			b = append(b, c)
+		}
+	}
+	if len(b) == 0 || string(b) == "." || string(b) == ".." {
+		return ""
+	}
+	return string(b)
 }
 
 func NewPluginFactory(name string, config map[string]interface{}) (sdk.Plugin, error) {
@@ -187,6 +214,13 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 	p.proxy = readCfg(s.Settings(), "proxy", "")
 	p.client = newHTTPClient(p.timeout, p.proxy)
 
+	// 持久化 profile 根目录：<data>/browser_profiles
+	if dd, err := s.Settings().GetCore("daemon.data_dir"); err == nil {
+		if s2, ok := dd.(string); ok && s2 != "" {
+			p.profilesDir = filepath.Join(s2, "browser_profiles")
+		}
+	}
+
 	tp := p.name + "_"
 
 	cleaner := func(output string) string {
@@ -242,12 +276,13 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 
 	s.RegisterTool(tp+"start", sdk.ToolDef{
 		Name:        tp + "start",
-		Description: "启动交互式浏览器会话(interactive 模式)。通过 CDP 连接 Chromium，支持导航、截图、点击、输入等操作。返回会话 ID。",
+		Description: "启动交互式浏览器会话。优先连接 systemd 托管的共享浏览器后端（登录态全机共享、各 agent 独立标签页）；后端未安装时返回 need_install 引导（调 browser_install）；无法安装时自动降级本地临时模式。同来源复用已有标签页。",
 		Parameters: map[string]interface{}{
 			"type": "object",
 			"properties": map[string]interface{}{
 				"url":     map[string]interface{}{"type": "string", "description": "初始导航 URL（可选）"},
 				"timeout": map[string]interface{}{"type": "string", "description": "会话超时(如 5m, 10m，默认 10m)"},
+				"profile": map[string]interface{}{"type": "string", "description": "持久化档案名（可选，如 main）。同名档案共享登录态与浏览历史；不指定则为一次性临时会话"},
 			},
 		},
 	}, p.handleBrowserStart)
@@ -337,6 +372,15 @@ func (p *Plugin) Start(s *sdk.PluginSDK) error {
 		},
 	}, p.handleScroll)
 
+	s.RegisterTool(tp+"install", sdk.ToolDef{
+		Name:        tp + "install",
+		Description: "安装并启动共享浏览器后端（homeagent-browser.service，systemd 托管）。前提：本机已有 chromium 二进制（无则先提示用户安装：apt install chromium 或等价命令）。安装后所有 agent 共享同一浏览器实例与登录态。",
+		Parameters: map[string]interface{}{
+			"type":       "object",
+			"properties": map[string]interface{}{},
+		},
+	}, p.handleBrowserInstall)
+
 	s.RegisterTool(tp+"close", sdk.ToolDef{
 		Name:        tp + "close",
 		Description: "关闭交互式浏览器会话，释放资源。",
@@ -663,6 +707,9 @@ func (p *Plugin) fetchWithChromium(rawURL string, maxChars int) (interface{}, er
 	}, nil
 }
 
+// handleRender 无头渲染 JS 页面并提取文本（normal 模式）。
+// 主路径走共享浏览器后端：开临时标签页（带全机登录态）→ 渲染 → 取 text → 关标签页；
+// 后端不可用时 failback 到独立 chromium --dump-dom（无登录态，仅保功能）。
 func (p *Plugin) handleRender(args map[string]interface{}) (interface{}, error) {
 	rawURL := readArg(args, "url", "")
 	if rawURL == "" {
@@ -672,32 +719,70 @@ func (p *Plugin) handleRender(args map[string]interface{}) (interface{}, error)
 		return errResult(err.Error()), nil
 	}
 	waitSec := int64(readArg(args, "wait", float64(0)))
-	if waitSec > 0 {
-		time.Sleep(time.Duration(waitSec) * time.Second)
+
+	var title, html string
+	rendered := false
+
+	ok, needInstall, _ := p.ensureBackend()
+	if ok {
+		remoteCtx, remoteCancel := chromedp.NewRemoteAllocator(context.Background(), cdpEndpoint)
+		defer remoteCancel()
+		tabCtx, tabCancel := chromedp.NewContext(remoteCtx)
+		defer tabCancel()
+		actions := []chromedp.Action{
+			chromedp.Navigate(rawURL),
+			chromedp.WaitReady("body"),
+		}
+		if waitSec > 0 {
+			actions = append(actions, chromedp.Sleep(time.Duration(waitSec)*time.Second))
+		}
+		actions = append(actions,
+			chromedp.Title(&title),
+			chromedp.OuterHTML("html", &html),
+		)
+		// 整体限时 30s，防慢页拖死工具
+		rctx, rcancel := context.WithTimeout(tabCtx, 30*time.Second)
+		defer rcancel()
+		if err := chromedp.Run(rctx, actions...); err == nil {
+			rendered = true
+		} else {
+			log.Printf("[%s] render via backend failed (%v), fallback to dump-dom", p.name, err)
+		}
+	} else if needInstall {
+		return map[string]interface{}{
+			"error":        "browser backend not installed",
+			"need_install": true,
+			"guide":        "调用 browser_install 安装共享后端；或重试本工具自动降级为独立 chromium 渲染（不带登录态）",
+		}, nil
 	}
-	var html string
-	chromiumPath := "/usr/local/bin/chromium"
-	if _, err := os.Stat(chromiumPath); err == nil {
+
+	if !rendered {
+		chromiumPath := "/usr/local/bin/chromium"
+		if _, err := os.Stat(chromiumPath); err != nil {
+			if _, e2 := exec.LookPath("chromium"); e2 == nil {
+				chromiumPath = "chromium"
+			} else {
+				return errResult("no chromium available"), nil
+			}
+		}
 		var out bytes.Buffer
 		cmd := exec.Command(chromiumPath, "--headless", "--disable-gpu", "--no-sandbox", "--dump-dom", rawURL)
 		cmd.Stdout = &out
-		if err := cmd.Run(); err != nil {
-			return errResult("chromium: " + err.Error()), nil
+		done := make(chan error, 1)
+		go func() { done <- cmd.Run() }()
+		select {
+		case err := <-done:
+			if err != nil {
+				return errResult("chromium: " + err.Error()), nil
+			}
+		case <-time.After(30 * time.Second):
+			cmd.Process.Kill()
+			<-done // 回收子进程避免僵尸
+			return errResult("chromium dump-dom timeout (30s)"), nil
 		}
 		html = out.String()
-	} else {
-		resp, err := http.Get(rawURL)
-		if err != nil {
-			return errResult("http get: " + err.Error()), nil
-		}
-		defer resp.Body.Close()
-		body, _ := io.ReadAll(resp.Body)
-		html = string(body)
-	}
-	title := ""
-	if m := regexp.MustCompile(`<title>([^<]+)</title>`).FindStringSubmatch(html); len(m) > 1 {
-		title = m[1]
 	}
+
 	text := htmlToText(html)
 	origLen := len(text)
 	truncated := origLen > 5000
@@ -712,18 +797,71 @@ func (p *Plugin) handleRender(args map[string]interface{}) (interface{}, error)
 	if truncated {
 		result += fmt.Sprintf("\n\n...(仅显示前 5000 字符，共 %d 字符)", origLen)
 	}
-	return map[string]interface{}{"content": result, "title": title}, nil
+	mode := "backend-tab"
+	if !rendered {
+		mode = "local-dump-dom"
+	}
+	return map[string]interface{}{"content": result, "title": title, "mode": mode}, nil
 }
 
-// ── Interactive Browser Session (CDP) ─────────────────────
-
-func (p *Plugin) handleBrowserStart(args map[string]interface{}) (interface{}, error) {
-	timeoutStr := readArg(args, "timeout", "10m")
-	timeout, err := time.ParseDuration(timeoutStr)
+func cdpReachable(endpoint string) bool {
+	client := &http.Client{Timeout: 2 * time.Second}
+	resp, err := client.Get(endpoint + "/json/version")
 	if err != nil {
-		timeout = 10 * time.Minute
+		return false
 	}
+	resp.Body.Close()
+	return resp.StatusCode == http.StatusOK
+}
 
+// systemdUnitActive 检查 homeagent-browser.service 是否已安装。
+func systemdUnitInstalled() bool {
+	out, err := exec.Command("systemctl", "cat", "homeagent-browser.service").CombinedOutput()
+	return err == nil && len(out) > 0
+}
+
+// startSystemdUnit 尝试 systemctl start（单元已安装但未运行时用）。
+func startSystemdUnit() error {
+	return exec.Command("systemctl", "start", "homeagent-browser.service").Run()
+}
+
+// cdpEndpoint 是共享 Chromium 后端的 CDP 地址（homeagent-browser.service）。
+const cdpEndpoint = "http://127.0.0.1:9222"
+
+// ensureBackend 确保共享浏览器后端可用：探测 → 拉起已装服务 → 报告未装。
+// 返回 (ok, needInstall, err)。
+func (p *Plugin) ensureBackend() (bool, bool, error) {
+	if cdpReachable(cdpEndpoint) {
+		return true, false, nil
+	}
+	if systemdUnitInstalled() {
+		if err := startSystemdUnit(); err == nil {
+			// 等待 CDP 就绪（chromium 启动 ~1-3s）
+			for i := 0; i < 10; i++ {
+				time.Sleep(500 * time.Millisecond)
+				if cdpReachable(cdpEndpoint) {
+					return true, false, nil
+				}
+			}
+		}
+		return false, false, fmt.Errorf("browser backend service installed but failed to start")
+	}
+	return false, true, nil // 未安装
+}
+
+// sharedTab 在共享后端上开一个新标签页（RemoteAllocator + NewContext）。
+func sharedTab(allocCtx context.Context) (context.Context, context.CancelFunc, error) {
+	tabCtx, tabCancel := chromedp.NewContext(allocCtx)
+	if err := chromedp.Run(tabCtx); err != nil {
+		tabCancel()
+		return nil, nil, err
+	}
+	return tabCtx, tabCancel, nil
+}
+
+// localSpawnFailback 本地拉起一次性 Chromium（离线机器无法装 systemd 服务的兜底）。
+// 用临时 profile，登录态不跨会话保留——仅保证功能可用。
+func (p *Plugin) localSpawnFailback() (context.Context, context.CancelFunc, context.CancelFunc, error) {
 	opts := append(chromedp.DefaultExecAllocatorOptions[:],
 		chromedp.Flag("headless", true),
 		chromedp.Flag("disable-gpu", true),
@@ -733,23 +871,83 @@ func (p *Plugin) handleBrowserStart(args map[string]interface{}) (interface{}, e
 	if p.proxy != "" {
 		opts = append(opts, chromedp.Flag("proxy-server", p.proxy))
 	}
-
-	allocCtx, cancel := chromedp.NewExecAllocator(context.Background(), opts...)
+	allocCtx, cancelAlloc := chromedp.NewExecAllocator(context.Background(), opts...)
 	ctx, _ := chromedp.NewContext(allocCtx)
-
-	// 立即分配浏览器和 Target，确保后续 Run 的 timeout context 不会杀死浏览器进程
-	// chromedp 官方警告：首调用带 timeout 的 Run 会杀死整个浏览器
 	if err := chromedp.Run(ctx); err != nil {
-		cancel()
-		return errResult("browser init failed: " + err.Error()), nil
+		cancelAlloc()
+		return nil, nil, nil, err
+	}
+	return allocCtx, cancelAlloc, nil, nil
+}
+
+func (p *Plugin) handleBrowserStart(args map[string]interface{}) (interface{}, error) {
+	timeoutStr := readArg(args, "timeout", "10m")
+	timeout, err := time.ParseDuration(timeoutStr)
+	if err != nil {
+		timeout = 10 * time.Minute
 	}
 
-	session := &BrowserSession{
-		allocCtx:  allocCtx,
-		cancel:    cancel,
-		ctx:       ctx,
-		createdAt: time.Now(),
-		timeout:   timeout,
+	source := readArg(args, "source", "")
+	if source == "" {
+		source = "default"
+	}
+
+	// 同 source 复用已有标签页
+	p.mu.Lock()
+	for _, s := range p.sessions {
+		if s.shared && s.sessionKey == source && !s.closed {
+			s.mu.Lock()
+			id := s.id
+			cur := s.currentURL
+			s.mu.Unlock()
+			p.mu.Unlock()
+			return map[string]interface{}{
+				"id":     id,
+				"status": "reused",
+				"url":    cur,
+				"note":   "已复用本来源的现有标签页（登录态全机共享）",
+			}, nil
+		}
+	}
+	p.mu.Unlock()
+
+	var session *BrowserSession
+
+	// 路径一：systemd 托管的共享后端（主路径）
+	ok, needInstall, berr := p.ensureBackend()
+	if ok {
+		remoteCtx, remoteCancel := chromedp.NewRemoteAllocator(context.Background(), cdpEndpoint)
+		probe, _ := chromedp.NewContext(remoteCtx)
+		if err := chromedp.Run(probe); err != nil {
+			remoteCancel()
+			return errResult("connect to browser backend failed: " + err.Error()), nil
+		}
+		tabCtx, tabCancel := chromedp.NewContext(remoteCtx)
+		if err := chromedp.Run(tabCtx); err != nil {
+			remoteCancel()
+			return errResult("open tab failed: " + err.Error()), nil
+		}
+		session = &BrowserSession{
+			allocCtx:   remoteCtx,
+			cancel:     tabCancel,
+			ctx:        tabCtx,
+			createdAt:  time.Now(),
+			timeout:    timeout,
+			shared:     true,
+			sessionKey: source,
+		}
+	} else if needInstall {
+		guide := "浏览器后端未安装。请确认后调用 browser_install 工具完成安装：" +
+			"需要本机有 chromium 二进制（apt install chromium 或等价命令），" +
+			"插件会注册 homeagent-browser.service 并启动。" +
+			"若本机无法联网安装 chromium，可继续用本地临时模式（重试 browser_start 即自动降级）。"
+		return map[string]interface{}{
+			"error":       "backend not installed",
+			"need_install": true,
+			"guide":        guide,
+		}, nil
+	} else {
+		return errResult("browser backend error: " + berr.Error()), nil
 	}
 
 	p.mu.Lock()
@@ -761,7 +959,7 @@ func (p *Plugin) handleBrowserStart(args map[string]interface{}) (interface{}, e
 
 	initURL := readArg(args, "url", "")
 	if initURL != "" {
-		if err := chromedp.Run(ctx,
+		if err := chromedp.Run(session.ctx,
 			chromedp.Navigate(initURL),
 			chromedp.WaitReady("body"),
 		); err != nil {
@@ -772,13 +970,13 @@ func (p *Plugin) handleBrowserStart(args map[string]interface{}) (interface{}, e
 			return errResult("navigate failed: " + err.Error()), nil
 		}
 		session.currentURL = initURL
-		p.sdk.InjectTextNoMemory(p.name, p.name, fmt.Sprintf("[浏览器 %s 已打开 %s]", id, initURL))
 	}
 
-	log.Printf("[%s] created browser session %s: url=%s timeout=%v", p.name, id, initURL, timeout)
+	log.Printf("[%s] created browser session %s: url=%s timeout=%v source=%s", p.name, id, initURL, timeout, source)
 	return map[string]interface{}{
 		"id":      id,
 		"status":  "created",
+		"mode":    "shared-backend",
 		"url":     initURL,
 		"timeout": timeout.String(),
 	}, nil
@@ -1019,3 +1217,104 @@ func (p *Plugin) cleanupLoop() {
 		}
 	}
 }
+
+// ── browser_install：安装 systemd 托管的共享浏览器后端 ──────────
+
+// handleBrowserInstall 注册 homeagent-browser.service 并启动，验证 CDP 可达。
+// 返回给 agent 的结果含全机共享使用指南（由 agent 转述给用户）。
+func (p *Plugin) handleBrowserInstall(args map[string]interface{}) (interface{}, error) {
+	if cdpReachable(cdpEndpoint) {
+		return map[string]interface{}{"status": "already_running", "endpoint": cdpEndpoint}, nil
+	}
+
+	// 探测 chromium 二进制
+	chromePath := ""
+	for _, c := range []string{
+		"/usr/bin/chromium", "/usr/bin/chromium-browser",
+		"/usr/local/bin/chromium", "/usr/bin/google-chrome",
+	} {
+		if _, err := os.Stat(c); err == nil {
+			chromePath = c
+			break
+		}
+	}
+	if out, err := exec.LookPath("chromium"); err == nil && chromePath == "" {
+		chromePath = out
+	} else if out, err := exec.LookPath("google-chrome"); err == nil && chromePath == "" {
+		chromePath = out
+	}
+	if chromePath == "" {
+		return map[string]interface{}{
+			"error": "chromium binary not found",
+			"hint":  "请先安装 chromium：apt install chromium 或等价命令，然后重试 browser_install",
+		}, nil
+	}
+
+	profileDir := ""
+	if p.profilesDir != "" {
+		profileDir = filepath.Join(p.profilesDir, "shared")
+		os.MkdirAll(profileDir, 0755)
+	} else {
+		// profilesDir 未注入（无 data_dir），退到 /var/lib/homeagent-browser
+		profileDir = "/var/lib/homeagent-browser"
+		os.MkdirAll(profileDir, 0755)
+	}
+
+	unit := fmt.Sprintf(`[Unit]
+Description=HomeAgent Shared Browser Backend (headless chromium, CDP :9222)
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=%s --headless --no-sandbox --disable-gpu --disable-dev-shm-usage --remote-debugging-port=9222 --user-data-dir=%s --window-size=1280,800 about:blank
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+`, chromePath, profileDir)
+
+	unitPath := "/etc/systemd/system/homeagent-browser.service"
+	if err := os.WriteFile(unitPath, []byte(unit), 0644); err != nil {
+		return map[string]interface{}{
+			"error": "write unit failed (need root): " + err.Error(),
+			"hint":  "插件进程无权限写 /etc/systemd/system 时，请让用户手动执行安装命令（见 manual_cmds）",
+			"manual_cmds": []string{
+				"sudo tee /etc/systemd/system/homeagent-browser.service <<'EOF'\n" + unit + "EOF",
+				"sudo systemctl daemon-reload",
+				"sudo systemctl enable --now homeagent-browser.service",
+			},
+		}, nil
+	}
+	for _, cmd := range [][]string{
+		{"systemctl", "daemon-reload"},
+		{"systemctl", "enable", "--now", "homeagent-browser.service"},
+	} {
+		if out, err := exec.Command(cmd[0], cmd[1:]...).CombinedOutput(); err != nil {
+			return map[string]interface{}{
+				"error": fmt.Sprintf("%v: %s", cmd, string(out)),
+			}, nil
+		}
+	}
+	// 等待 CDP 就绪
+	for i := 0; i < 20; i++ {
+		time.Sleep(500 * time.Millisecond)
+		if cdpReachable(cdpEndpoint) {
+			guide := "共享浏览器后端已就绪（CDP " + cdpEndpoint + "）。\n" +
+				"全机共享说明：本机所有 agent（HomeAgent、pi、opencode、deepseekharness 等）都可连接此实例：" +
+				"登录一次全机可用；各 agent 各自占用独立标签页互不干扰；\n" +
+				"- HomeAgent 内部：browser_start 即自动连接本后端\n" +
+				"- 其他 agent：让其浏览器工具/MCP 连接 CDP 端点 " + cdpEndpoint + "（如 playwright connectOverCDP / puppeteer connect）\n" +
+				"- 服务由 systemd 托管：崩溃自动重启，登录态持久保存在 " + profileDir
+			log.Printf("[%s] browser backend installed and running (chrome=%s profile=%s)", p.name, chromePath, profileDir)
+			return map[string]interface{}{
+				"status":   "installed",
+				"endpoint": cdpEndpoint,
+				"chrome":    chromePath,
+				"profile":  profileDir,
+				"guide":    guide,
+			}, nil
+		}
+	}
+	return map[string]interface{}{"error": "service started but CDP not reachable after 10s"}, nil
+}

example/calendar/README.md

@@ -5,7 +5,7 @@ calendar plugin
 ## Build
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
 ## Install

example/calendar/plg.json

@@ -2,14 +2,19 @@
   "name": "calendar",
   "name_zh": "日历",
   "name_en": "Calendar",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "日历事件管理，支持提醒和重复事件",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["calendar", "event", "reminder", "schedule"],
+  "tags": [
+    "calendar",
+    "event",
+    "reminder",
+    "schedule"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/calendar/plugin.go

@@ -520,7 +520,8 @@ func (p *Plugin) checkReminders() {
 	p.mu.Unlock()
 
 	for _, msg := range injectMsgs {
-		p.sdk.InjectInterruptText("calendar", "calendar", msg)
+		// NoMemory：日程到点提醒，不是记忆内容。
+		p.sdk.InjectInterruptTextOpts("calendar", "calendar", msg, sdk.InjectOptions{NoMemory: true})
 	}
 }
 
@@ -656,7 +657,7 @@ func (p *Plugin) saveEventsLocked() {
 		NextEventID: p.nextEventID,
 	}
 	b, _ := json.MarshalIndent(data, "", "  ")
-	os.WriteFile(p.eventsFile(), b, 0644)
+	atomicWriteJSON(p.eventsFile(), b)
 }
 
 // --- Helper: parse remind_before ---
@@ -1177,3 +1178,12 @@ func (p *Plugin) handleSearch(args map[string]interface{}) (interface{}, error)
 	}
 	return map[string]interface{}{"content": strings.Join(lines, "\n")}, nil
 }
+
+// atomicWriteJSON 原子写 JSON：先写临时文件再 rename，避免进程崩溃截断数据文件。
+func atomicWriteJSON(path string, data []byte) error {
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}

example/luademo/README.md

@@ -17,7 +17,7 @@ lua main.lua   # 使用 sdk.lua mock，不依赖内核
 ## 构建
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
 ## 安装

example/luademo/main.lua

@@ -76,9 +76,13 @@ function plugin.start(sdk)
     return nil
   end, "own_tools")
 
-  -- 阶段钩子：全局作用域
+  -- 阶段钩子：全局作用域（修改 ctx 字段会写回内核，见 applyLuaStageResult）
   sdk.register_stage("pre_action", function(ctx)
     sdk.log("info", "luademo stage pre_action: user=" .. tostring(ctx.user_id))
+    -- 演示 stage 写回：给 llm_text 追加标记（内核会同步回 StageContext）
+    if ctx.llm_text then
+      ctx.llm_text = ctx.llm_text .. "[luademo]"
+    end
     return nil
   end)
 

example/memo/plg.json

@@ -2,14 +2,18 @@
   "name": "memo",
   "name_zh": "备忘录",
   "name_en": "Memo",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "待办与备忘录插件。待办（todo_add/todo_complete/todo_list）会主动提醒；备忘录（memo_create/memo_list/memo_delete）纯记事不提醒。",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["memo", "todo", "notes"],
+  "tags": [
+    "memo",
+    "todo",
+    "notes"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/memo/plugin.go

@@ -224,7 +224,7 @@ func (p *Plugin) saveTodos() {
 		"next_id": p.nextTID,
 	}, "", "  ")
 	p.mu.RUnlock()
-	os.WriteFile(p.todoPath, data, 0644)
+	atomicWriteJSON(p.todoPath, data)
 }
 
 func (p *Plugin) saveMemos() {
@@ -234,7 +234,7 @@ func (p *Plugin) saveMemos() {
 		"next_id": p.nextMID,
 	}, "", "  ")
 	p.mu.RUnlock()
-	os.WriteFile(p.memoPath, data, 0644)
+	atomicWriteJSON(p.memoPath, data)
 }
 
 // ── 待办：未完成计数与提醒 ──
@@ -292,8 +292,9 @@ func (p *Plugin) periodicCheck() {
 				continue
 			}
 			if p.sdk != nil {
-				p.sdk.InjectInterruptText(p.name, p.name,
-					fmt.Sprintf("注意，你还有%d条待办未完成，请检查", n))
+				// NoMemory：这是定时提醒，不是记忆内容。
+				p.sdk.InjectInterruptTextOpts(p.name, p.name,
+					fmt.Sprintf("注意，你还有%d条待办未完成，请检查", n), sdk.InjectOptions{NoMemory: true})
 			}
 		}
 	}
@@ -500,3 +501,12 @@ func (p *Plugin) cleanupData() {
 		os.Remove(p.memoPath)
 	}
 }
+
+// atomicWriteJSON 原子写 JSON：先写临时文件再 rename，避免进程崩溃截断数据文件。
+func atomicWriteJSON(path string, data []byte) error {
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}

example/qq/plg.json

@@ -2,14 +2,17 @@
   "name": "qq",
   "name_zh": "QQ消息",
   "name_en": "qq",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "QQ 消息收发插件，通过 NapCat 协议桥接",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["qq", "messaging"],
+  "tags": [
+    "qq",
+    "messaging"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": false,
   "replaces": {},
   "source_dirs": []
-}
+}

example/qq/plugin_test.go

@@ -0,0 +1,204 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"gitcode.com/JianFeeeee/homeagent-sdk/sdk"
+)
+
+func newPermissionTestPlugin(t *testing.T) *Plugin {
+	t.Helper()
+	instance, err := NewPluginFactory("qq", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return instance.(*Plugin)
+}
+
+func toolCallContext(name string, args map[string]interface{}) *sdk.StageContext {
+	return &sdk.StageContext{ToolCalls: []sdk.ToolCall{{Name: name, Arguments: args}}}
+}
+
+func TestOwnerBypassesQQPermissionBoundary(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	ctx := toolCallContext("calendar_list", nil)
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response != nil {
+		t.Fatalf("owner call rejected: %s", *ctx.Response)
+	}
+}
+
+func TestPrivateResourceCannotBeAllowlisted(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.privateToolAllowlist = append(p.privateToolAllowlist, "calendar_*")
+	p.auth = qqAuthContext{active: true, userID: 10001}
+	ctx := toolCallContext("calendar_list", nil)
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response == nil || !strings.Contains(*ctx.Response, "私人资源工具") {
+		t.Fatalf("expected private-resource denial, got %#v", ctx.Response)
+	}
+}
+
+func TestNonOwnerQQHistoryIsScopedToCurrentGroup(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.auth = qqAuthContext{active: true, messageID: 88, userID: 10001, groupID: 20002, isGroup: true}
+
+	ctx := toolCallContext("qq_get_history", map[string]interface{}{"group_id": int64(20003)})
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response == nil || !strings.Contains(*ctx.Response, "当前 QQ 会话") {
+		t.Fatalf("cross-group history not rejected: %#v", ctx.Response)
+	}
+
+	ctx = toolCallContext("qq_get_history", map[string]interface{}{"group_id": int64(20002)})
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response != nil {
+		t.Fatalf("current-group history rejected: %s", *ctx.Response)
+	}
+}
+
+func TestUnmatchedQQInputIsDowngraded(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	ctx := &sdk.StageContext{
+		RawMessage: "来自未知事件(message_id=404)",
+		Extra:      map[string]interface{}{"input_source": "qq"},
+	}
+	if err := p.onInputAuthContext(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if !p.auth.active || p.auth.owner || p.auth.userID != 0 {
+		t.Fatalf("unmatched input reused prior privilege: %+v", p.auth)
+	}
+}
+
+func TestDuplicateQQOutputIsStopped(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.maxDuplicateSend = 1
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	args := map[string]interface{}{"payload": "same", "type": "text", "meta": `{"user_id":123}`}
+
+	ctx := toolCallContext("output_send__qq", args)
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response != nil {
+		t.Fatalf("first send rejected: %s", *ctx.Response)
+	}
+
+	ctx = toolCallContext("output_send__qq", args)
+	if err := p.beforeToolcall(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if ctx.Response == nil || !strings.Contains(*ctx.Response, "循环保险") {
+		t.Fatalf("duplicate send not stopped: %#v", ctx.Response)
+	}
+}
+
+func TestGroupAndUserRouteAddsLeadingMention(t *testing.T) {
+	var path string
+	var request map[string]interface{}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path = r.URL.Path
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			t.Errorf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"status":"ok","retcode":0,"data":{"message_id":1}}`))
+	}))
+	defer server.Close()
+
+	p := newPermissionTestPlugin(t)
+	p.napcatURL = server.URL
+	p.httpClient = server.Client()
+	_, err := p.handleChannelOutput(map[string]interface{}{
+		"payload": "hello",
+		"type":    "text",
+		"meta":    `{"group_id":20002,"user_id":10001}`,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if path != "/send_group_msg" {
+		t.Fatalf("path=%q, want /send_group_msg", path)
+	}
+	segments, ok := request["message"].([]interface{})
+	if !ok || len(segments) < 2 {
+		t.Fatalf("message is not a segment array: %#v", request["message"])
+	}
+	mention, _ := segments[0].(map[string]interface{})
+	data, _ := mention["data"].(map[string]interface{})
+	if mention["type"] != "at" || data["qq"] != "10001" {
+		t.Fatalf("leading mention=%#v", mention)
+	}
+}
+
+// 回归：循环保险曾按“总数”拦截，导致参数不同且必需的调用被误杀。
+// 现在只拦参数完全相同的重复调用。
+func TestDistinctQQOutputsAreNotTreatedAsDuplicates(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	// maxDuplicateSend 默认 1：同一条消息重复才会被拦，不同消息必须全部放行。
+	for i := 0; i < 5; i++ {
+		ctx := toolCallContext("output_send__qq", map[string]interface{}{
+			"payload": fmt.Sprintf("message-%d", i),
+			"type":    "text",
+			"meta":    `{"user_id":123}`,
+		})
+		if err := p.beforeToolcall(ctx); err != nil {
+			t.Fatal(err)
+		}
+		if ctx.Response != nil {
+			t.Fatalf("distinct message %d was blocked: %s", i, *ctx.Response)
+		}
+	}
+}
+
+func TestDistinctNecessaryToolCallsAreNotBlocked(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	// 旧实现 maxQQToolCalls=32 会在第 33 个不同参数的必需调用处误拦。
+	for i := 0; i < 50; i++ {
+		ctx := toolCallContext("cmd_run", map[string]interface{}{"command": fmt.Sprintf("cmd-%d", i)})
+		if err := p.beforeToolcall(ctx); err != nil {
+			t.Fatal(err)
+		}
+		if ctx.Response != nil {
+			t.Fatalf("necessary tool call %d was blocked: %s", i, *ctx.Response)
+		}
+	}
+}
+
+func TestZeroLimitsMeanUnlimited(t *testing.T) {
+	p := newPermissionTestPlugin(t)
+	p.maxQQOutputCalls = 0
+	p.maxDuplicateSend = 0
+	p.maxQQToolCalls = 0
+	p.auth = qqAuthContext{active: true, owner: true, userID: 2198972886}
+	for i := 0; i < 30; i++ {
+		ctx := toolCallContext("output_send__qq", map[string]interface{}{
+			"payload": "same-content",
+			"type":    "text",
+			"meta":    `{"user_id":123}`,
+		})
+		if err := p.beforeToolcall(ctx); err != nil {
+			t.Fatal(err)
+		}
+		if ctx.Response != nil {
+			t.Fatalf("0 should mean unlimited, blocked at %d: %s", i, *ctx.Response)
+		}
+	}
+}

example/recoverydiag/diag_test.go

@@ -0,0 +1,153 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+var realCfg = "/home/newqqagent/config.db"
+var realLog = "/home/newqqagent/log"
+
+func TestDiagTriage(t *testing.T) {
+	p := &Plugin{name: "recoverydiag"}
+
+	cases := []struct {
+		name string
+		args map[string]interface{}
+		want string
+	}{
+		{"signal", map[string]interface{}{"exit_code": 0, "signal": "SIGSEGV"}, "process_death"},
+		{"oom", map[string]interface{}{"exit_code": 0, "signal": "SIGKILL", "crash_reason": "oom-kill"}, "process_starvation"},
+		{"nonzero", map[string]interface{}{"exit_code": 1}, "process_death"},
+		{"healthy", map[string]interface{}{"exit_code": 0}, "normal_stop"},
+		{"alive", map[string]interface{}{"still_alive": true, "signal": "SIGKILL"}, "config_unreachable"},
+	}
+	for _, c := range cases {
+		r, _ := p.handleTriage(c.args)
+		m, ok := r.(map[string]interface{})
+		if !ok {
+			t.Fatalf("%s: not a map", c.name)
+		}
+		if got, _ := m["class"].(string); got != c.want {
+			t.Errorf("%s: class = %q, want %q", c.name, got, c.want)
+		}
+	}
+}
+
+func TestDiagDB(t *testing.T) {
+	if _, err := os.Stat(realCfg); err != nil {
+		t.Skip("config.db not present, skipping")
+	}
+	p := &Plugin{name: "recoverydiag"}
+	r, err := p.handleDB(map[string]interface{}{"db_path": realCfg})
+	if err != nil {
+		t.Fatalf("handleDB: %v", err)
+	}
+	m := r.(map[string]interface{})
+	t.Logf("integrity=%v sources=%v verdict=%v summary=%v", m["integrity"], m["source_count"], m["verdict"], m["summary"])
+	if m["integrity"] != "ok" {
+		t.Errorf("integrity = %v, want ok", m["integrity"])
+	}
+	if m["source_count"] == 0 {
+		t.Errorf("source_count == 0, expected LLM sources")
+	}
+	if got, _ := m["source_failed"].(int); got != 0 {
+		t.Errorf("source_failed = %d, want 0 (all sources OK): %v", got, m["missing_fields"])
+	}
+}
+
+func TestDiagLogScan(t *testing.T) {
+	if _, err := os.Stat(realLog); err != nil {
+		t.Skip("log dir not present, skipping")
+	}
+	p := &Plugin{name: "recoverydiag"}
+	r, err := p.handleLogScan(map[string]interface{}{
+		"log_dir":       realLog,
+		"since_minutes": 60 * 24 * 3,
+	})
+	if err != nil {
+		t.Fatalf("handleLogScan: %v", err)
+	}
+	m := r.(map[string]interface{})
+	t.Logf("matched=%v counts=%v dominant=%v conclusion=%v", m["lines_matched"], m["counts"], m["dominant"], m["conclusion"])
+}
+
+func TestDiagDelta(t *testing.T) {
+	base := t.TempDir()
+	cur := t.TempDir()
+	sub := filepath.Join(base, "sub")
+	os.MkdirAll(sub, 0755)
+
+	// modified: same path, different content
+	os.WriteFile(filepath.Join(base, "a.txt"), []byte("hello"), 0644)
+	os.WriteFile(filepath.Join(cur, "a.txt"), []byte("world!"), 0644)
+	// created
+	os.WriteFile(filepath.Join(cur, "b.txt"), []byte("new"), 0644)
+	// deleted
+	os.WriteFile(filepath.Join(base, "gone.txt"), []byte("bye"), 0644)
+	// unchanged
+	os.WriteFile(filepath.Join(base, "same.txt"), []byte("x"), 0644)
+	os.WriteFile(filepath.Join(cur, "same.txt"), []byte("x"), 0644)
+
+	p := &Plugin{name: "recoverydiag"}
+	r, err := p.handleDelta(map[string]interface{}{"baseline_dir": base, "current_dir": cur})
+	if err != nil {
+		t.Fatalf("handleDelta: %v", err)
+	}
+	m := r.(map[string]interface{})
+	sum := m["summary"].(map[string]int)
+	t.Logf("summary=%v total=%v", sum, m["total_diff"])
+	if sum["created"] != 1 || sum["deleted"] != 1 || sum["modified"] != 1 {
+		t.Errorf("summary = %v, want modified=1 created=1 deleted=1", sum)
+	}
+}
+
+func TestDiagLoc(t *testing.T) {
+	p := &Plugin{name: "recoverydiag"}
+	r, _ := p.handleLoc(map[string]interface{}{
+		"triage":   map[string]interface{}{"class": "process_death", "verdict": "down"},
+		"db":       map[string]interface{}{"verdict": "ok"},
+		"log_scan": map[string]interface{}{"dominant": "panic"},
+		"delta":    map[string]interface{}{"summary": map[string]interface{}{"created": 0, "modified": 0, "deleted": 0}},
+	})
+	m := r.(map[string]interface{})
+	// 经 JSON 往返，模拟内核把子结论以 JSON 传给 diag_loc 的真实路径
+	raw, _ := json.Marshal(m)
+	var dec map[string]interface{}
+	json.Unmarshal(raw, &dec)
+	hs := dec["ranked_hypotheses"].([]interface{})
+	if len(hs) == 0 {
+		t.Fatal("no hypotheses")
+	}
+	top := hs[0].(map[string]interface{})
+	t.Logf("top cause=%v conf=%v rec=%v", top["cause"], top["confidence"], top["recommendation"])
+	if top["cause"] != "code_panic_loop" {
+		t.Errorf("expected code_panic_loop, got %v", top["cause"])
+	}
+}
+
+func TestDiagLocPersist(t *testing.T) {
+	kb := filepath.Join(t.TempDir(), "recovery_kb")
+	p := &Plugin{name: "recoverydiag", dataDir: filepath.Dir(kb)}
+	args := map[string]interface{}{
+		"persist":  true,
+		"triage":   map[string]interface{}{"class": "process_death", "verdict": "down"},
+		"db":       map[string]interface{}{"verdict": "ok"},
+		"log_scan": map[string]interface{}{"dominant": "panic"},
+		"delta":    map[string]interface{}{"summary": map[string]interface{}{"created": 0, "modified": 0, "deleted": 0}},
+	}
+	if _, err := p.handleLoc(args); err != nil {
+		t.Fatalf("handleLoc: %v", err)
+	}
+	entries, err := os.ReadDir(kb)
+	if err != nil || len(entries) == 0 {
+		t.Fatalf("expected persisted diag json, got err=%v entries=%v", err, entries)
+	}
+	data, _ := os.ReadFile(filepath.Join(kb, entries[0].Name()))
+	if !strings.Contains(string(data), `"cause"`) {
+		t.Errorf("persisted file missing cause field: %s", data)
+	}
+}

example/recoverydiag/go.mod

@@ -0,0 +1,7 @@
+module recoverydiag
+
+go 1.25.0
+
+require gitcode.com/JianFeeeee/homeagent-sdk v0.0.0
+
+replace gitcode.com/JianFeeeee/homeagent-sdk => ../../

example/recoverydiag/main.go

@@ -0,0 +1,11 @@
+//go:build !windows || !cgo
+
+package main
+
+import (
+	sdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
+)
+
+func NewPlugin(name string, config map[string]interface{}) (sdk.Plugin, error) {
+	return NewPluginFactory(name, config)
+}

example/recoverydiag/plg.json

@@ -0,0 +1,21 @@
+{
+  "name": "recoverydiag",
+  "name_zh": "恢复诊断",
+  "name_en": "Recovery Diagnostics",
+  "version": "0.2.0",
+  "description": "快速检查/崩溃取证工具集：diag_triage（退出码/信号/存活粗分）、diag_db（config.db 完整性 + LLM 源解析校验）、diag_log_scan（日志签名命中）、diag_delta（last-good 快照 vs 现状 diff）、diag_loc（正交综合定位）。全部返回结论而非原文，确定性、不消耗 LLM token，供 guard / failback 恢复决策使用。",
+  "author": "HomeAgent",
+  "entry": "plugin.so",
+  "tags": [
+    "diag",
+    "recovery",
+    "diagnostics",
+    "triage",
+    "failback"
+  ],
+  "targets": "linux/amd64",
+  "outdir": "dist",
+  "bundle": true,
+  "replaces": {},
+  "source_dirs": []
+}

example/rss/README.md

@@ -5,7 +5,7 @@ rss plugin
 ## Build
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
 ## Install

example/rss/plg.json

@@ -2,14 +2,19 @@
   "name": "rss",
   "name_zh": "RSS订阅",
   "name_en": "RSS",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "RSS/Atom 订阅监控插件，自动检测更新并推送通知",
   "author": "HomeAgent",
   "entry": "plugin.so",
-  "tags": ["rss", "feed", "subscription", "monitor"],
+  "tags": [
+    "rss",
+    "feed",
+    "subscription",
+    "monitor"
+  ],
   "targets": "linux/amd64",
   "outdir": "dist",
   "bundle": true,
   "replaces": {},
   "source_dirs": []
-}
+}

example/rss/plugin.go

@@ -300,7 +300,10 @@ func (p *Plugin) checkFeed(sub FeedSub) {
 		lines = append(lines, line)
 	}
 
-	p.sdk.InjectInterruptText("rss", "rss", strings.Join(lines, "\n"))
+	// 中断注入是「系统通知」，NoMemory 写明意图：这类提醒不参与记忆计算，
+	// 原文仍进上下文（模型当轮看得到）。
+	p.sdk.InjectInterruptTextOpts("rss", "rss", strings.Join(lines, "\n"),
+		sdk.InjectOptions{NoMemory: true})
 	p.saveData()
 }
 
@@ -467,7 +470,7 @@ func (p *Plugin) saveData() {
 		SeenGUIDs: p.seenGUIDs,
 	}
 	b, _ := json.MarshalIndent(data, "", "  ")
-	os.WriteFile(p.dataFile(), b, 0644)
+	atomicWriteJSON(p.dataFile(), b)
 }
 
 // cleanupData 卸载时清理订阅数据目录（feeds.json 等）
@@ -486,3 +489,12 @@ func (p *Plugin) cleanupData() {
 }
 
 
+
+// atomicWriteJSON 原子写 JSON：先写临时文件再 rename，避免进程崩溃截断数据文件。
+func atomicWriteJSON(path string, data []byte) error {
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}

example/weather/README.md

@@ -5,7 +5,7 @@ weather plugin
 ## Build
 
 ```bash
-plugindev build
+hmapdev build
 ```
 
 ## Install

meta/meta.go

@@ -1,12 +1,56 @@
 // Package meta 收集 HomeAgent SDK 的全部元数据。
 // 版本号应与核心 meta.Version 保持一致。
-// ABI 版本与 Dispatch Method ID 应与核心仓 internal/meta/meta.go 保持一致。
 package meta
 
 var (
 	// Version 是 HomeAgent SDK 版本号。
 	// 通过 `-ldflags="-X gitcode.com/JianFeeeee/homeagent-sdk/meta.Version=vX.Y.Z"` 注入。
-	Version = "0.9.0"
+	//
+	// 版本号语义：**SDK 版本跟随核心的中版本，patch 位恒为 .0**。
+	// 整条核心 1.1.x 线（1.1.0、1.1.1、1.1.7…）共用 SDK 1.1.0；
+	// 只有核心进入 1.2.0 这种中版本跃迁时 SDK 才升到 1.2.0。
+	// 这样插件开发者只需关心「我在为哪个中版本写插件」，
+	// 不必跟着核心的每个 bugfix 换 SDK 依赖（见 核心仓 docs/git-branching.md §七）。
+	//
+	// 1.0.0：插件运行模型从 C ABI 动态库改为子进程 + 共享内存。
+	//        公开 SDK 接口零改动，但产物形态变了（plugin.so → plugin.bin）。
+	// 1.1.0：多模态贯通插件边界。**全部是新增，无签名变更**：
+	//          - Triple.SentenceText / Triple.MediaDigests
+	//          - Doc.MediaDigests / Doc.Attachments、MediaAttachment
+	//          - TextEvent.Attachments
+	//          - DocMemoryAPI.InsertWithMedia
+	//          - IOInjector 的 InjectInputMedia / InjectInputMediaSync /
+	//            InjectInterruptMedia；PluginSDK 补上缺失的 SetToolBlocks 包装
+	//        同版修掉两处并发竞态（sdk/stress_test.go 的 -race 实证，不是理论风险）：
+	//        PluginSDK 的 API 字段与 autoRestart 标志此前无锁，而写方
+	//        （内核注入 API、插件 SetAutoRestart）与读方（插件后台 goroutine
+	//        注入、内核 registry 读 AutoRestart）天然跨 goroutine。
+	//        存量插件不需要改一行也不需要重编：新增方法由**插件调用、内核实现**，
+	//        不调就不受影响。想用新字段的插件重编即可。
+	//
+	// 1.2.0：注入行为的记忆/裁剪标志位。**全部是新增，无签名变更**：
+	//          - InjectOptions{NoMemory, ContextPolicy}
+	//          - IOInjector 的六个 *Opts 变体（排队/中断/同步/带媒体各一对）
+	//          - ChannelDef.ContextPolicy（顺带给 ChannelDef 补上 JSON tag：
+	//            它要跨进程传给内核，而 Cleaner 是函数必须忽略；无 tag 时只能
+	//            手写字段白名单，新增字段会被静默丢掉）
+	//        语义：零值 InjectOptions 与旧的三参数方法完全等价（记入记忆 +
+	//        不裁剪），因此存量插件不需要改一行也不需要重编。
+	//        裁剪（ContextPolicy=prune）必须显式声明——它会归档丢弃低相关事件。
+	//
+	// ❗main 分支上此值是**下一个未发布中版本**；已发布的值看对应的
+	// release/vX.Y.x 分支与 tag（见 核心仓 docs/git-branching.md §2.1 与 §七.1）。
+	//
+	// 现为 1.2.0：核心的 1.2.x 线正在发布中（release/v1.2.x 承载 1.2.0），
+	// 但 **SDK 不跟 beta 发版**（§七.2）——SDK 1.2.0 的定版与 tag 随核心的
+	// **正式** tag 一起做（§七.3）。在那之前 1.2.0 仍是 SDK 尚未发布的中版本，
+	// 所以 main 就停在 1.2.0。
+	//
+	// 注意：这里与核心 main **故意不对称**。核心一旦切出 release/v1.2.x，
+	// 1.2.0 就归发布线所有，main 立刻推进到 1.3.0；而 SDK 因为要等正式 tag，
+	// 它的 main 在 v1.2.0 打出来之前不得越过 1.2.0。
+	// （曾误按 §七.4 把这里推到 1.3.0，等于宣称 1.2.0 已发布。）
+	Version = "1.2.0"
 
 	// Commit 是构建时的 Git commit hash。
 	Commit = "unknown"
@@ -17,11 +61,23 @@ var (
 	// SDKName 是 SDK 名称。
 	SDKName = "HomeAgent SDK"
 
-	// CoreModule 是核心仓的 Go module path，供 plugindev 生成 go.mod 时使用。
+	// CoreModule 是核心仓的 Go module path，供 hmapdev 生成 go.mod 时使用。
 	CoreModule = "gitcode.com/JianFeeeee/HomeAgent"
 
 	// CoreVersion 是此 SDK 所兼容的最低核心版本。
-	CoreVersion = "0.9.0"
+	//
+	// 1.0.0 是硬下限而非建议值：0.9.x 内核只会 dlopen `.so`，
+	// 本版工具链产出的 `plugin.bin` 在旧内核上根本不会被识别。
+	//
+	// ⚠️ 1.1.0 新增的媒体接口需要核心 **1.1.1+**（更早的核心没有
+	// doc.insertWithMedia / io.injectMedia* 这些 RPC，调用会返回 unknown method）。
+	// 这里仍写 1.0.0，因为它是「SDK 能在其上运行」的下限；
+	// 媒体接口是可选能力，不用就不受影响。
+	//
+	// ⚠️ 1.2.0 新增的注入标志位同理需要核心 **1.2.0+**：内核在 1.2.0 之前会
+	// 忽略注入参数里的 no_memory/context_policy 字段（不会报错，但不生效）。
+	// 想用这些标志位的插件应当要求核心 1.2.0+；不用就不受影响。
+	CoreVersion = "1.0.0"
 )
 
 // FullVersion 返回完整的版本字符串。
@@ -29,74 +85,15 @@ func FullVersion() string {
 	return SDKName + " v" + Version + " (" + Commit + ")"
 }
 
-// ---- ABI 版本（与核心仓 internal/meta/meta.go 同步） ----
-// ABI 标识版本直接取内核版本号字符串（semver），与核心 Version 保持一致，不使用独立数字编码。
-// 协商层（C 结构体 int version 字段）使用 CABINum：由版本字符串派生的整数（major*100 + minor）。
-// 映射：v0.8.x → CABINum=800；v0.9.x → CABINum=900（invoke_stage 写回）。
-// 小版本（patch）演进不影响 ABI，CABINum 不变。version_min 保证旧 ABI 插件仍可加载。
-
-var (
-	// ABIVersion 是 ABI 标识版本（字符串 semver，与 SDK CoreVersion 对齐）。
-	ABIVersion = CoreVersion
-	// ABIVersionMin 是兼容的最低 ABI 标识版本。
-	ABIVersionMin = "0.8.0"
-)
-
-const (
-	// CABINum 是 C 层协商用的整数版本（major*100 + minor），随 ABIVersion 派生。
-	CABINum = 900
-	// CABINumMin 是 C 层兼容的最低整数版本。
-	// 旧工具链（v0.8 之前）写入的整数 version=1，无写回能力但与新内核结构兼容，
-	// 因此最小值保持 1 以兼容全部旧插件（新插件 900 匹配，旧插件 1/2 通过）；
-	// 仅当未来内核 ABI 破坏兼容时才提高该值。
-	CABINumMin = 1
-)
-
-// ---- Dispatch Method IDs（与核心仓 internal/meta/meta.go 同步） ----
-const (
-	CoreRegisterTool          = 1
-	CoreRegisterStage         = 2
-	CoreRegisterOutputCh      = 3
-	CoreRegisterPluginAPI     = 4
-	CoreInjectText            = 5
-	CoreInjectInterruptText   = 6
-	CoreInjectTextNoMemory    = 7
-	CoreSetAutoRestart        = 8
-	CoreMemoryRecall          = 9
-	CoreMemoryCommit          = 10
-	CoreMemoryIntrospect      = 11
-	CoreMemoryMerge           = 12
-	CoreMemoryPurge           = 13
-	CoreDocQuery              = 14
-	CoreKnowledgeSearch       = 15
-	CoreSettingsGet           = 16
-	CoreSettingsSet           = 17
-	CoreSettingsRegisterDef   = 18
-	CoreLLMListSources        = 19
-	CoreLLMSetSource          = 20
-	CoreSocialGetPerson       = 21
-	CoreSocialGetNetwork      = 22
-	CoreSubscribe             = 23
-	CoreUnsubscribe           = 24
-	CoreFreeString            = 25
-	CoreSettingsGetCore       = 26
-	CoreSettingsSetCore       = 27
-	CoreSettingsListCore      = 28
-	CoreSettingsGetPlugin     = 29
-	CoreSettingsSetPlugin     = 30
-	CoreSettingsListPlugin    = 31
-	CoreDocInsert             = 32
-	CoreDocRemove             = 33
-	CoreDocStats              = 34
-	CoreKnowledgeAdd          = 35
-	CoreKnowledgeList         = 36
-	CoreLLMCurrentSource      = 37
-	CoreSocialGetTrait        = 38
-	CoreSocialGetRelations    = 39
-	CoreSocialListPersons     = 40
-	CoreTextMemoryAppend      = 41
-	CoreSettingsList          = 42
-	CoreSettingsDefs          = 43
-	CoreSettingsDump          = 44
-	CoreSettingsPlugins       = 45
-)
+// ---- 协议版本 ----
+//
+// 子进程 RPC 的协议版本是一个独立的小整数，与 SDK/内核语义版本解耦：
+// 语义版本变动频繁（修 bug、加字段），而 wire 协议只在**帧格式或握手语义**
+// 变化时才升。当前值见核心仓 internal/plugin/proc/protocol.go 的 ProtocolVersion。
+//
+// C ABI 时代的 ABIVersion / CABINum / 51 个 Core<Method> 整数 ID 已随
+// Part 6.2 删除 internal/plugin/cabi/ 一并退场：
+//   - 整数 method id 平移为 method 名字符串（proc/protocol.go 的 Method* 常量）
+//   - 版本协商改为握手帧里的 protocol 字段
+//
+// 保留那些常量只会让人以为它们还在生效。

package/build-examples.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# 给 SDK 发版打包**示例插件**的 .hmap 产物。
+#
+# 为什么要在 SDK 仓库里发示例插件的 hmap：
+#   插件二进制与内核是**协议绑定**的（internal/plugin/proc/protocol.go 的
+#   ProtocolVersion + 统一共享内存区魔数）。SDK 升版往往同时意味着协议变化，
+#   而示例插件（qq/memo/browser/…）是使用者最常直接安装的东西。
+#   如果 SDK 只发工具链不发示例产物，使用者要么自己重编、要么用到与本版 SDK
+#   不匹配的旧产物——后者的表现是握手失败（协议/魔数不匹配），而且看起来像
+#   「插件坏了」而不是「版本不配套」。
+#
+# 用法：
+#   package/build-examples.sh [TARGET] [OUT_DIR]
+#     TARGET   native(默认) | linux/amd64 | linux/arm64 | darwin/amd64 | darwin/arm64 | windows/amd64 | all
+#     OUT_DIR  产物目录（默认 build/examples）
+#
+# 产物：
+#   <OUT_DIR>/<name>_<goos>_<goarch>.hmap   每个示例插件一份
+#   <OUT_DIR>/SHA256SUMS                    全部产物齐全**之后**才计算
+#   <OUT_DIR>/MANIFEST.txt                  版本、协议版本、产自哪个 commit
+#
+# 纪律（与本项目其它构建脚本一致）：
+#   1. 判成功看**产物是否存在**，不看退出码——hmapdev 对部分错误只打印不退出。
+#   2. SHA256SUMS 必须在全部产物生成完毕后一次算完，边打边算会漏掉后生成的包。
+set -uo pipefail
+
+SDK_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+TARGET="${1:-native}"
+OUT_DIR="${2:-$SDK_ROOT/build/examples}"
+GO="${GO:-$(command -v go 2>/dev/null || echo go)}"
+
+case "$TARGET" in
+  native)        GOOS=""; GOARCH="" ;;
+  linux/amd64)   GOOS=linux;   GOARCH=amd64 ;;
+  linux/arm64)   GOOS=linux;   GOARCH=arm64 ;;
+  darwin/amd64)  GOOS=darwin;  GOARCH=amd64 ;;
+  darwin/arm64)  GOOS=darwin;  GOARCH=arm64 ;;
+  windows/amd64)
+    # 明确拒绝，而不是让调用方拿到一句深层 Go 编译错误。
+    # 协议 2 的统一共享内存区只移植到了 Unix：内核 internal/plugin/proc/
+    # shmpass_windows.go 仍是旧的 SHM_STAGE/SHM_EVTRING 两段布局，
+    # 插件模板 proc_shm_windows.go 也缺 attachUnifiedShm。
+    echo "windows 目标暂不支持：协议 2 的统一共享内存区未移植到 Windows（内核与插件模板均缺实现）。" >&2
+    exit 1
+    ;;
+  all)
+    echo "本脚本一次只构建一个平台；请由 package/build.sh 传入具体目标。" >&2
+    exit 1
+    ;;
+  *)
+    echo "Unknown target: $TARGET" >&2
+    echo "Usage: $0 [native|linux/amd64|linux/arm64|darwin/amd64|darwin/arm64|windows/amd64|all] [OUT_DIR]" >&2
+    exit 1
+    ;;
+esac
+
+export CGO_ENABLED=0
+
+# 按平台逐个构建，**不用** bundle 模式：
+#   - bundle 会连 windows 一起编，而协议 2 的统一共享区尚未移植到 Windows
+#     （内核 shmpass_windows.go 仍是旧的两段布局），必然失败；
+#   - 逐平台构建每个目标都产出一份 .hmap，正是发版要附的产物。
+# 平台名解析成本脚本后面用（校验和与 MANIFEST 都要写清楚是哪个平台）。
+if [ -z "${GOOS:-}" ]; then
+  GOOS="$(go env GOOS)"; GOARCH="$(go env GOARCH)"
+fi
+
+# 1) 先保证工具链可用：示例必须用**本仓当前源码**构建，否则产物协议与这一版 SDK 不符。
+#    允许外部指定（发版脚本会在跨平台构建后把刚产出的工具链路径传进来）。
+# 工具链二进制名由 plugindev 改为 hmapdev；旧变量名 PLUGINDEV 仍兼容。
+HMAPDEV="${HMAPDEV:-${PLUGINDEV:-$SDK_ROOT/build/hmapdev}}"
+if [ ! -x "$PLUGINDEV" ]; then
+  echo "[examples] 先构建 hmapdev ..."
+  ( cd "$SDK_ROOT/tools/hmapdev" && "$GO" build -o "$HMAPDEV" . ) || {
+    echo "[examples] hmapdev 构建失败，无法继续" >&2; exit 1; }
+fi
+if [ ! -x "$PLUGINDEV" ]; then
+  echo "[examples] hmapdev 不存在或不可执行：$HMAPDEV" >&2
+  exit 1
+fi
+
+echo "=== 协议 ==="
+echo "  ProtocolVersion = $(grep -m1 '^const ProtocolVersion' "$SDK_ROOT/../internal/plugin/proc/protocol.go" 2>/dev/null | grep -oE '[0-9]+' || echo '?（本仓非内核仓，跳过）')"
+
+mkdir -p "$OUT_DIR"
+# 清掉上一次的校验和：残留的 SHA256SUMS 会掩盖本次缺产物。
+rm -f "$OUT_DIR"/SHA256SUMS "$OUT_DIR"/MANIFEST.txt
+
+ok=0
+fail=0
+failed_names=""
+
+for dir in "$SDK_ROOT"/example/*/; do
+  [ -f "$dir/plugin.go" ] || continue
+  name="$(basename "$dir")"
+
+  # 清掉旧产物：残留会让人（和本脚本）误判成功。
+  rm -rf "$dir/build" "$dir/dist"
+
+  out=$( cd "$dir" && "$PLUGINDEV" build --no-bundle --target "$GOOS/$GOARCH" 2>&1 )
+  rc=$?
+
+  # 判据是**退出码 + 产物存在**，两者都要。
+  #   只看退出码：hmapdev 曾经出错也退 0（已修，但脚本不该依赖它「现在」是对的）。
+  #   只看产物：部分平台失败时会留下上一次的产物，看起来像成功。
+  hmap="$(ls "$dir"/dist/*.hmap 2>/dev/null | head -1)"
+  if [ $rc -eq 0 ] && [ -n "$hmap" ]; then
+    # 保留插件自己声明的产物名（它用的是 plg.json 的 name_en，是插件的身份），
+    # 只在前面加平台前缀避免多平台互相覆盖。
+    dest="$OUT_DIR/${GOOS}_${GOARCH}_$(basename "$hmap")"
+    cp "$hmap" "$dest"
+    printf "✓ %-14s → %s (%s)\n" "$name" "$(basename "$dest")" "$(du -h "$dest" | cut -f1)"
+    ok=$((ok + 1))
+  else
+    printf "✗ %-14s 构建失败 (rc=%d)\n" "$name" "$rc"
+    echo "$out" | tail -6 | sed 's/^/      /'
+    fail=$((fail + 1))
+    failed_names="$failed_names $name"
+  fi
+done
+
+echo
+echo "示例产物: 成功 $ok / 失败 $fail"
+[ -n "$failed_names" ] && echo "失败:$failed_names"
+
+# 有失败就不算发版闭环：宁可整个中断，也不要发出「少几个插件」的包。
+if [ $fail -ne 0 ]; then
+  echo "[examples] 有示例构建失败，不生成 SHA256SUMS" >&2
+  exit 1
+fi
+
+# 2) 全部产物齐了才算校验和。
+( cd "$OUT_DIR" && sha256sum ./*.hmap > SHA256SUMS )
+
+VERSION="${VERSION:-$(git -C "$SDK_ROOT" describe --tags --dirty 2>/dev/null || echo unknown)}"
+COMMIT="${COMMIT:-$(git -C "$SDK_ROOT" rev-parse --short HEAD 2>/dev/null || echo unknown)}"
+{
+  echo "sdk_version: $VERSION"
+  echo "sdk_commit:  $COMMIT"
+  echo "target:      $GOOS/$GOARCH"
+  echo "plugins:     $ok"
+  echo "built_at:    $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  echo
+  echo "这些 .hmap 与本版 SDK 的插件协议绑定，必须与同版本内核配套安装。"
+  echo "校验：sha256sum -c SHA256SUMS"
+} > "$OUT_DIR/MANIFEST.txt"
+
+echo "[examples] 产物: $OUT_DIR"
+echo "[examples] 清单: $OUT_DIR/MANIFEST.txt"
+echo "[examples] 校验: $OUT_DIR/SHA256SUMS"

package/build.sh

@@ -5,6 +5,13 @@ PROJECT_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 BUILD_DIR="${PROJECT_ROOT}/build"
 VERSION="${VERSION:-$(git -C "$PROJECT_ROOT" describe --tags --dirty 2>/dev/null || echo "0.7.1")}"
 GO="${GO:-$(command -v go 2>/dev/null || echo "/home/jianf/go1.26.5/go/bin/go")}"
+# 宿主平台必须在**本脚本 export GOOS/GOARCH 之前**取定。
+# 否则 `go env GOOS` 会返回被 export 的目标平台（此前 `build.sh all all`
+# 就是因此拿 darwin 二进制在 linux 上跑，报 cannot execute binary file）。
+NATIVE_GOOS="$(env -u GOOS -u GOARCH "$GO" env GOOS 2>/dev/null || uname -s | tr 'A-Z' 'a-z')"
+NATIVE_GOARCH="$(env -u GOOS -u GOARCH "$GO" env GOARCH 2>/dev/null || uname -m)"
+case "$NATIVE_GOARCH" in x86_64|amd64) NATIVE_GOARCH="amd64" ;; aarch64|arm64) NATIVE_GOARCH="arm64" ;; esac
+case "$NATIVE_GOOS" in darwin|linux|windows) ;; *) NATIVE_GOOS="linux" ;; esac
 GOCACHE="${GOCACHE:-}"
 GOPATH="${GOPATH:-}"
 
@@ -28,7 +35,7 @@ case "$TARGET" in
     ;;
   *)
     echo "Unknown target: $TARGET"
-    echo "Usage: $0 [native|linux/amd64|linux/arm64|darwin/amd64|darwin/arm64|windows/amd64|all] [all|plugindev]"
+    echo "Usage: $0 [native|linux/amd64|linux/arm64|darwin/amd64|darwin/arm64|windows/amd64|all] [all|hmapdev|examples]"
     exit 1
 esac
 
@@ -42,12 +49,12 @@ export CGO_ENABLED=0
 
 mkdir -p "$BUILD_DIR"
 
-build_plugindev() {
-  local src="tools/plugindev"
-  local out="$BUILD_DIR/plugindev${SUFFIX:+_$SUFFIX}"
+build_hmapdev() {
+  local src="tools/hmapdev"
+  local out="$BUILD_DIR/hmapdev${SUFFIX:+_$SUFFIX}"
   if [ "$GOOS" = "windows" ]; then out="${out}.exe"; fi
 
-  echo "[BUILD] plugindev ${GOOS:-linux}/${GOARCH:-amd64} → $out"
+  echo "[BUILD] hmapdev ${GOOS:-linux}/${GOARCH:-amd64} → $out"
   cd "$PROJECT_ROOT/$src"
   "$GO" build -trimpath -ldflags "-X gitcode.com/JianFeeeee/homeagent-sdk/meta.Version=${VERSION}" \
     -o "$out" .
@@ -55,9 +62,47 @@ build_plugindev() {
   cd "$PROJECT_ROOT"
 }
 
+# 示例插件产物随 SDK 一起发。
+#
+# 为什么必须发：插件二进制与内核是**协议绑定**的（ProtocolVersion + 统一共享
+# 内存区魔数）。SDK 升版常伴随协议变化，只发工具链不发示例产物，使用者很可能
+# 拿旧产物去装，表现是握手失败（魔数不匹配）——看起来像「插件坏了」而不是
+# 「版本不配套」。
+#
+# 用**宿主可执行**的那把工具链（而非 PATH 里的），保证产物与本次发版同源。
+#
+# 为什么不能用目标平台的那把：示例的跨平台构建是由 hmapdev 的 `--target GOOS/GOARCH`
+# 完成的，被执行的进程本身必須能在当前机器上跑。拿目标平台的二进制去跑只会得到
+# “cannot execute binary file: Exec format error”（`build.sh all all` 在 darwin 处断过）。
+build_examples() {
+  local dev
+  dev="$BUILD_DIR/hmapdev_${NATIVE_GOOS}_${NATIVE_GOARCH}"
+  [ "$NATIVE_GOOS" = "windows" ] && dev="${dev}.exe"
+  # 宿主工具链缺失时先补建（`all` 的第一个目标可能不是宿主平台）。
+  if [ ! -x "$dev" ]; then
+    echo "[BUILD] 先补建宿主工具链 ${NATIVE_GOOS}/${NATIVE_GOARCH}（示例的跨平台由 --target 完成）"
+    ( unset GOOS GOARCH; bash "$0" "${NATIVE_GOOS}/${NATIVE_GOARCH}" hmapdev ) || return 1
+  fi
+  if [ ! -x "$dev" ]; then
+    echo "[BUILD] 无法构建示例：缺少宿主可执行的工具链 $dev" >&2
+    echo "        先跑： $0 ${NATIVE_GOOS}/${NATIVE_GOARCH} hmapdev" >&2
+    return 1
+  fi
+  echo "[BUILD] example plugins ${GOOS:-linux}/${GOARCH:-amd64} → $BUILD_DIR/examples（用 ${NATIVE_GOOS}/${NATIVE_GOARCH} 的工具链交叉构建）"
+  PLUGINDEV="$dev" VERSION="$VERSION" bash "$PROJECT_ROOT/package/build-examples.sh" "$TARGET" "$BUILD_DIR/examples"
+  echo "  OK"
+}
+
 case "$COMPONENT" in
-  all|plugindev) build_plugindev ;;
+  all)
+    # 工具链必须先建完：示例用它来构建（同源保证协议一致）。
+    build_hmapdev
+    build_examples
+    ;;
+  hmapdev) build_hmapdev ;;
+  examples)  build_examples ;;
   *)
     echo "Unknown component: $COMPONENT"
     exit 1
+    ;;
 esac

package/toolchain.nsi

@@ -48,7 +48,7 @@ Function pageConfirm
   ${EndIf}
   ${NSD_CreateLabel} 0 5u 100% 12u "将安装以下组件:"
   Pop $0
-  ${NSD_CreateLabel} 15u 20u 100% 12u "• plugindev.exe  — 插件开发工具"
+  ${NSD_CreateLabel} 15u 20u 100% 12u "• hmapdev.exe  — 插件开发工具"
   Pop $0
   ${NSD_CreateLabel} 15u 35u 100% 12u "• SDK ${SDK_VERSION} — 将从远程仓库自动下载"
   Pop $0
@@ -64,11 +64,11 @@ Section "Install" SEC_INSTALL
   SetOutPath "$INSTDIR"
   
   DetailPrint "复制工具链文件..."
-  File "plugindev.exe"
+  File "hmapdev.exe"
 
   DetailPrint "创建快捷方式..."
   CreateDirectory "$SMPROGRAMS\${PRODUCT_NAME}"
-  CreateShortCut "$SMPROGRAMS\${PRODUCT_NAME}\plugindev.lnk" "$INSTDIR\plugindev.exe" "" "$INSTDIR\plugindev.exe" 0
+  CreateShortCut "$SMPROGRAMS\${PRODUCT_NAME}\hmapdev.lnk" "$INSTDIR\hmapdev.exe" "" "$INSTDIR\hmapdev.exe" 0
 
   DetailPrint "配置环境变量..."
   ; Add to system PATH
@@ -93,23 +93,23 @@ Section "Install" SEC_INSTALL
     DetailPrint "Git 已安装: $1"
   ${Else}
     DetailPrint "未检测到 Git，将跳过 SDK 自动下载"
-    DetailPrint "安装完成后请手动运行: plugindev sdk install ${SDK_VERSION}"
+    DetailPrint "安装完成后请手动运行: hmapdev sdk install ${SDK_VERSION}"
   ${EndIf}
 
   ${If} $hasGit == "1"
     DetailPrint "正在下载 SDK ${SDK_VERSION}..."
-    nsExec::ExecToStack '"$INSTDIR\plugindev.exe" sdk install ${SDK_VERSION}'
+    nsExec::ExecToStack '"$INSTDIR\hmapdev.exe" sdk install ${SDK_VERSION}'
     Pop $0
     Pop $1
     ${If} $0 == 0
       StrCpy $sdkInstallOk "1"
       DetailPrint "SDK ${SDK_VERSION} 下载完成"
       DetailPrint "正在激活 SDK ${SDK_VERSION}..."
-      nsExec::Exec '"$INSTDIR\plugindev.exe" sdk use ${SDK_VERSION}'
+      nsExec::Exec '"$INSTDIR\hmapdev.exe" sdk use ${SDK_VERSION}'
       Pop $0
     ${Else}
       DetailPrint "SDK 下载失败 (错误码: $0)"
-      DetailPrint "请手动运行: plugindev sdk install ${SDK_VERSION}"
+      DetailPrint "请手动运行: hmapdev sdk install ${SDK_VERSION}"
     ${EndIf}
   ${EndIf}
 
@@ -126,10 +126,10 @@ SectionEnd
 
 Section "Uninstall"
   Delete "$INSTDIR\Uninstall.exe"
-  Delete "$INSTDIR\plugindev.exe"
+  Delete "$INSTDIR\hmapdev.exe"
   RMDir /r "$INSTDIR\sdk"
   RMDir "$INSTDIR"
-  Delete "$SMPROGRAMS\${PRODUCT_NAME}\plugindev.lnk"
+  Delete "$SMPROGRAMS\${PRODUCT_NAME}\hmapdev.lnk"
   RMDir "$SMPROGRAMS\${PRODUCT_NAME}"
   DeleteRegValue HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "HOMEAGENT_SDK_DIR"
   DeleteRegKey HKLM "Software\Microsoft\CurrentVersion\Uninstall\${PRODUCT_NAME}"

remotedevice/CMakeLists.txt

@@ -0,0 +1,116 @@
+cmake_minimum_required(VERSION 3.10)
+project(ha_remotedevice VERSION 0.1.0 LANGUAGES C)
+
+# ============================================================
+# ha_remotedevice — HomeAgent 远程设备接入 C SDK
+# 零外部依赖，纯 C 实现，兼容嵌入式平台。
+#
+# 使用方式:
+#   add_subdirectory(path/to/ha_remotedevice)
+#   target_link_libraries(my_app ha_remotedevice)
+#   target_include_directories(my_app PRIVATE
+#     ${HA_REMOTEDEVICE_INCLUDE_DIR})
+# ============================================================
+
+# 选项: 构建为静态库或动态库
+option(BUILD_SHARED_LIBS "Build ha_remotedevice as shared library" OFF)
+
+# 选项: 禁用 malloc/free（用于裸机环境，用户需提供 alloc 回调）
+option(HA_NO_ALLOC  "Disable dynamic memory allocation" OFF)
+
+# 选项: 日志级别
+set(HA_LOG_LEVEL 2 CACHE STRING "Log level: 0=none, 1=error, 2=info, 3=debug")
+
+# 源文件
+set(HA_REMOTEDEVICE_SRC
+    src/ha_remotedevice.c
+    src/ha_json.c
+    src/ha_ws.c
+)
+
+# 头文件
+set(HA_REMOTEDEVICE_INCLUDE
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+# 编译选项
+if(HA_NO_ALLOC)
+    add_definitions(-DHA_NO_ALLOC)
+endif()
+add_definitions(-DHA_LOG_LEVEL=${HA_LOG_LEVEL})
+
+# 创建库
+if(BUILD_SHARED_LIBS)
+    add_library(ha_remotedevice SHARED ${HA_REMOTEDEVICE_SRC})
+    if(WIN32)
+        # Windows 需要导出符号
+        set_target_properties(ha_remotedevice PROPERTIES
+            WINDOWS_EXPORT_ALL_SYMBOLS ON)
+    endif()
+else()
+    add_library(ha_remotedevice STATIC ${HA_REMOTEDEVICE_SRC})
+endif()
+
+# 包含目录
+target_include_directories(ha_remotedevice
+    PUBLIC  ${HA_REMOTEDEVICE_INCLUDE}
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+# 不链接任何外部库
+target_link_libraries(ha_remotedevice PRIVATE)
+
+# 导出包含目录供外部项目使用
+set(HA_REMOTEDEVICE_INCLUDE_DIR
+    ${HA_REMOTEDEVICE_INCLUDE}
+    CACHE INTERNAL "ha_remotedevice include directories")
+
+# 安装规则
+install(TARGETS ha_remotedevice
+    EXPORT  ha_remotedevice-targets
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
+)
+
+install(DIRECTORY include/
+    DESTINATION include
+)
+
+install(EXPORT ha_remotedevice-targets
+    DESTINATION lib/cmake/ha_remotedevice
+    NAMESPACE ha_remotedevice::
+)
+
+# ============================================================
+# 测试（可选）
+# ============================================================
+option(BUILD_TESTS "Build ha_remotedevice tests" OFF)
+
+if(BUILD_TESTS)
+    find_package(Threads REQUIRED)
+
+    add_executable(ha_remotedevice_test
+        test/test_ha_remotedevice.c
+    )
+    target_link_libraries(ha_remotedevice_test
+        PRIVATE ha_remotedevice Threads::Threads
+    )
+    target_include_directories(ha_remotedevice_test
+        PRIVATE ${HA_REMOTEDEVICE_INCLUDE_DIR}
+    )
+
+    # 添加测试
+    add_test(NAME ha_remotedevice_test
+        COMMAND ha_remotedevice_test
+    )
+endif()
+
+# ============================================================
+# 编译信息
+# ============================================================
+message(STATUS "ha_remotedevice ${PROJECT_VERSION}")
+message(STATUS "  Build type: $<CONFIG>")
+message(STATUS "  Shared lib: ${BUILD_SHARED_LIBS}")
+message(STATUS "  No alloc:   ${HA_NO_ALLOC}")

remotedevice/include/ha_remotedevice.h

@@ -0,0 +1,216 @@
+#ifndef HA_REMOTEDEVICE_H
+#define HA_REMOTEDEVICE_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ==================================================================
+ *  ha_remotedevice — 远程设备接入 C SDK
+ *
+ *  零外部依赖，纯 C 实现，兼容嵌入式平台。
+ *  传输层由用户实现（4 个函数指针），SDK 处理所有协议细节。
+ *
+ *  声明式设计:
+ *    设备在代码中声明自己是什么(kind)和能做什么(caps)，
+ *    声明支持哪些命令(shell/camerasue/screensee/...)并注册对应处理函数，
+ *    SDK 自动处理协议握手、心跳、消息路由、结果回执。
+ *
+ *  协议流程:
+ *    TCP 连接 → WS 升级 → hello(设备声明) → bind(令牌) → 就绪
+ *    就绪后循环：读帧 → 按 handlers 表分发命令 → 自动回执结果
+ * ================================================================== */
+
+/* ======================== 状态码 ======================== */
+typedef enum {
+    HA_OK               = 0,
+    HA_ERR_GENERIC      = -1,
+    HA_ERR_NOMEM        = -2,
+    HA_ERR_INVALID      = -3,
+    HA_ERR_TIMEOUT      = -4,
+    HA_ERR_DISCONNECTED = -5,
+    HA_ERR_PROTOCOL     = -6,
+    HA_ERR_TRANSPORT    = -7,
+    HA_ERR_NOT_FOUND    = -8,
+} ha_status_t;
+
+/* ======================== 传输层抽象 ========================
+ *
+ * 用户必须实现这 4 个函数，适配不同平台（FreeRTOS+lwIP、Zephyr、裸机等）。
+ *
+ *  connect(ctx, host, port) → 建立 TCP 连接，返回 0 成功
+ *  send(ctx, data, len)     → 发送 len 字节，返回实际发送字节数，-1 失败
+ *  recv(ctx, buf, len)      → 接收最多 len 字节，返回实际接收字节数，0 断开，-1 失败
+ *  close(ctx)               → 关闭连接
+ */
+typedef struct {
+    int  (*connect)(void *ctx, const char *host, uint16_t port);
+    int  (*send)(void *ctx, const uint8_t *data, int len);
+    int  (*recv)(void *ctx, uint8_t *buf, int len);
+    void (*close)(void *ctx);
+    void *ctx;
+} ha_transport_t;
+
+/* ======================== 设备声明 ========================
+ *
+ * 声明式配置：设备在代码中声明自己的类型和能力。
+ * 这些信息通过 hello 消息发送给网关。
+ *
+ *  device_id  — 唯一标识，如 "esp32-cam-1"
+ *  name       — 设备显示名，如 "门口摄像头"
+ *  kind       — 设备种类，如 "camera"、"computer"、"speaker"、"light"
+ *  caps       — 能力数组，以 NULL 结尾，如 {"camera","status",NULL}
+ *  info_json  — 额外信息（JSON 字符串），可选，如 '{"chip":"ESP32-S3","psram":8}'
+ */
+typedef struct {
+    const char   *device_id;
+    const char   *name;
+    const char   *kind;
+    const char  **caps;        /* NULL 结尾 */
+    const char   *info_json;   /* 可选，NULL 或 JSON 字符串 */
+} ha_device_info_t;
+
+/* ======================== 命令结果 ========================
+ *
+ * 命令处理函数通过填写此结构体返回数据。
+ * SDK 收到结果后自动发送回执（文本或二进制分块）。
+ *
+ * 使用方式：
+ *   1. 简单文本：设置 status=0, output="结果文本"
+ *   2. 二进制数据：设置 has_binary=1, binary_data/binary_len/mime
+ *   3. 错误：设置 status=1, error="错误信息"
+ *
+ * 注意：output 字符串由 SDK 内部 strdup 后发送，handler 返回后即可释放。
+ *       我们约定 handler 不负责分配，由 SDK 在内部做好拷贝。
+ *       所以 handler 可以返回栈上或静态字符串。
+ */
+typedef struct {
+    int         status;          /* 0=ok, 非0=error */
+    const char *output;          /* 输出文本（如 base64 图像数据），SDK 内部拷贝 */
+    const char *error;           /* 错误信息 */
+    int         has_binary;      /* 1=通过二进制分块回传 */
+    const char *binary_mime;     /* 二进制 MIME 类型 */
+    const uint8_t *binary_data;  /* 二进制数据指针 */
+    int         binary_len;      /* 二进制数据长度 */
+} ha_cmd_result_t;
+
+/* ======================== 命令处理声明 ========================
+ *
+ * 声明式命令注册：设备在配置中声明支持哪些命令，并绑定处理函数。
+ *
+ *  command 值说明：
+ *   - "shell"               → 处理 shell 类型命令，args 为完整命令字符串
+ *   - "camerasue"            → 处理 homeagent-camerasue 命令，args 为参数
+ *   - "screensee"            → 处理 homeagent-screensee 命令
+ *   - "speakeruse"           → 处理 homeagent-speakeruse 命令
+ *   - "computeruse"          → 处理 homeagent-computeruse 命令
+ *   - "clipboardsee"         → 处理 homeagent-clipboardsee 命令
+ *   - "clipboardsue"         → 处理 homeagent-clipboardsue 命令
+ *   - "screensue"            → 处理 homeagent-screensue 命令
+ *   - "deviceinfo"           → 处理设备信息查询
+ *   - 其他自定义命令名       → 按字符串匹配分发
+ *
+ * handler 处理完毕后只需填写 result 结构体，SDK 自动回执。
+ */
+typedef ha_status_t (*ha_cmd_handler_t)(const char *req_id, const char *args,
+                                        ha_cmd_result_t *result, void *userdata);
+
+typedef struct {
+    const char        *command;    /* 命令名，如 "camerasue"、"shell" */
+    ha_cmd_handler_t   handler;    /* 处理函数 */
+} ha_cmd_handler_def_t;
+
+/* 二进制数据接收回调：收到服务端推送的二进制数据（如 TTS 音频）时调用。
+ *  data 指针在回调返回后失效，如需保存请拷贝。 */
+typedef void (*ha_binary_handler_t)(const char *req_id, const char *kind,
+                                    const char *mime, const uint8_t *data,
+                                    int len, void *userdata);
+
+/* 连接状态变化回调 */
+typedef void (*ha_state_callback_t)(int connected, void *userdata);
+
+/* ======================== 客户端配置 ========================
+ *
+ * 所有配置在 ha_client_new() 时一次性声明。
+ * 声明式核心：handlers 表声明了设备支持的所有命令及其处理函数。
+ */
+typedef struct {
+    ha_transport_t        transport;      /* 传输层实现（必须） */
+    ha_device_info_t      device;         /* 设备声明（必须） */
+    const char           *server;         /* 服务端地址，如 "192.168.1.100:9890"（必须） */
+    const char           *token;          /* 接入令牌（必须） */
+
+    ha_cmd_handler_def_t *handlers;       /* 声明式命令处理表，.command=NULL 标记结束 */
+    ha_binary_handler_t   on_binary;      /* 二进制数据接收回调（可选） */
+    ha_state_callback_t   on_state;       /* 状态变化回调（可选） */
+    void                 *userdata;       /* 用户自定义数据，传给所有回调 */
+
+    int                   ping_interval;  /* 心跳间隔秒数，0 则默认 30 */
+    int                   max_reconnect;  /* 最大重连次数，-1 无限重连（默认），0 不重连 */
+} ha_config_t;
+
+/* ======================== 客户端 API ======================== */
+
+typedef struct ha_client ha_client_t;
+
+/* 创建客户端实例。config 数据会在内部拷贝，外部可释放。 */
+ha_client_t *ha_client_new(const ha_config_t *config);
+
+/* 启动连接：TCP 连接 → WS 升级 → hello → bind → 就绪。阻塞直到完成或失败。 */
+ha_status_t  ha_client_start(ha_client_t *client);
+
+/* 主循环处理：必须在用户的主循环中周期性调用。
+ *   - 读取 WS 帧并分发
+ *   - 按 handlers 表查找命令处理函数，自动回执结果
+ *   - 处理心跳 ping/pong
+ *   - 处理断线重连
+ * 返回 HA_OK 表示正常，HA_ERR_DISCONNECTED 表示正在重连。 */
+ha_status_t  ha_client_process(ha_client_t *client);
+
+/* ===== 主动上报（设备主动推送，非命令响应） ===== */
+
+/* 发送设备主动上报事件。type 如 "motion_detected"，detail 为 JSON 字符串。 */
+void ha_client_send_event(ha_client_t *client, const char *type,
+                          const char *detail);
+
+/* 发送设备状态更新。status: "online"、"offline"、"busy" 等。 */
+void ha_client_send_status(ha_client_t *client, const char *status);
+
+/* ===== 生命周期 ===== */
+
+/* 停止客户端，断开连接。 */
+void ha_client_stop(ha_client_t *client);
+
+/* 销毁客户端，释放所有资源。 */
+void ha_client_destroy(ha_client_t *client);
+
+/* ======================== 工具函数 ======================== */
+
+/* 解析 homeagent-* 命令，返回能力名和参数。
+ *   command = "camerasue 5"   → cap="camerasue",  args="5"
+ *   command = "screensee"      → cap="screensee",  args=""
+ *   command = "computeruse {...}" → cap="computeruse", args="..."  */
+void ha_cmd_parse_homeagent(const char *command, const char **cap,
+                            const char **args);
+
+/* 解析 JSON 格式的命令参数，提取 action 和 JSON 字符串。
+ *   command = "computeruse {\"action\":\"click\",\"x\":100}"
+ *   → action="computeruse", json_str="{\"action\":\"click\",...}"  */
+void ha_cmd_parse_json(const char *command, const char **action,
+                       const char **json_str);
+
+/* Base64 编码（用于将二进制数据编码为文本回传）。
+ * 返回写入 out 的字节数（不含 \0），out 不足时返回所需长度。 */
+int ha_base64_encode(const uint8_t *data, int len, char *out, int out_len);
+
+/* 获取版本号 */
+const char *ha_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HA_REMOTEDEVICE_H */

remotedevice/src/ha_json.c

@@ -0,0 +1,369 @@
+#include "ha_json.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+
+/* ======================== 解析器 ======================== */
+
+/* 前向声明 */
+static ha_json_node_t *parse_value(const char **pp);
+
+/* 跳过空白 */
+static const char *skip_ws(const char *p) {
+    while (*p && (unsigned char)*p <= ' ') p++;
+    return p;
+}
+
+/* 解析字符串（"..."），返回新分配的字符串，p 更新到结束引号后 */
+static char *parse_string(const char **pp) {
+    const char *p = skip_ws(*pp);
+    if (*p != '"') return NULL;
+    p++;
+    int len = 0;
+    const char *q = p;
+    while (*q && *q != '"') {
+        if (*q == '\\') { q++; if (*q) q++; }
+        else q++;
+        len++;
+    }
+    if (*q != '"') return NULL;
+    char *s = (char *)malloc(len + 1);
+    if (!s) return NULL;
+    q = p;
+    int i = 0;
+    while (*q && *q != '"') {
+        if (*q == '\\') {
+            q++;
+            switch (*q) {
+                case '"':  s[i++] = '"'; break;
+                case '\\': s[i++] = '\\'; break;
+                case '/':  s[i++] = '/'; break;
+                case 'b':  s[i++] = '\b'; break;
+                case 'f':  s[i++] = '\f'; break;
+                case 'n':  s[i++] = '\n'; break;
+                case 'r':  s[i++] = '\r'; break;
+                case 't':  s[i++] = '\t'; break;
+                case 'u': q += 4; s[i++] = '?'; continue;
+                default: s[i++] = *q; break;
+            }
+            q++;
+        } else {
+            s[i++] = *q++;
+        }
+    }
+    s[i] = '\0';
+    *pp = q + 1;
+    return s;
+}
+
+static ha_json_node_t *new_node(ha_json_type_t type) {
+    ha_json_node_t *n = (ha_json_node_t *)calloc(1, sizeof(ha_json_node_t));
+    if (n) n->type = type;
+    return n;
+}
+
+/* 解析数字 */
+static ha_json_node_t *parse_number(const char **pp) {
+    const char *p = *pp;
+    int neg = 0;
+    if (*p == '-') { neg = 1; p++; }
+    if (!isdigit((unsigned char)*p)) return NULL;
+    int val = 0;
+    while (isdigit((unsigned char)*p)) {
+        val = val * 10 + (*p - '0');
+        p++;
+    }
+    if (*p == '.') { p++; while (isdigit((unsigned char)*p)) p++; }
+    if (*p == 'e' || *p == 'E') {
+        p++;
+        if (*p == '+' || *p == '-') p++;
+        while (isdigit((unsigned char)*p)) p++;
+    }
+    *pp = p;
+    ha_json_node_t *n = new_node(HA_JSON_INT);
+    if (n) n->int_val = neg ? -val : val;
+    return n;
+}
+
+/* 解析 true/false/null */
+static ha_json_node_t *parse_keyword(const char **pp) {
+    const char *p = *pp;
+    ha_json_node_t *n = NULL;
+    if (strncmp(p, "true", 4) == 0 && !isalnum((unsigned char)p[4])) {
+        n = new_node(HA_JSON_BOOL); if (n) n->bool_val = 1;
+        *pp = p + 4;
+    } else if (strncmp(p, "false", 5) == 0 && !isalnum((unsigned char)p[5])) {
+        n = new_node(HA_JSON_BOOL); if (n) n->bool_val = 0;
+        *pp = p + 5;
+    } else if (strncmp(p, "null", 4) == 0 && !isalnum((unsigned char)p[4])) {
+        n = new_node(HA_JSON_NULL);
+        *pp = p + 4;
+    }
+    return n;
+}
+
+/* 解析对象 */
+static ha_json_node_t *parse_object(const char **pp) {
+    const char *p = skip_ws(*pp);
+    if (*p != '{') return NULL;
+    p++;
+    ha_json_node_t *obj = new_node(HA_JSON_OBJECT);
+    if (!obj) return NULL;
+    ha_json_node_t **tail = &obj->child;
+    p = skip_ws(p);
+    if (*p == '}') { *pp = p + 1; return obj; }
+    while (*p) {
+        p = skip_ws(p);
+        char *key = parse_string(&p);
+        if (!key) break;
+        p = skip_ws(p);
+        if (*p != ':') { free(key); break; }
+        p++;
+        ha_json_node_t *val = parse_value(&p);
+        if (!val) { free(key); break; }
+        val->key = key;
+        *tail = val;
+        tail = &val->next;
+        p = skip_ws(p);
+        if (*p == ',') { p++; continue; }
+        if (*p == '}') break;
+    }
+    p = skip_ws(p);
+    if (*p == '}') { *pp = p + 1; return obj; }
+    ha_json_free(obj);
+    return NULL;
+}
+
+/* 解析数组 */
+static ha_json_node_t *parse_array(const char **pp) {
+    const char *p = skip_ws(*pp);
+    if (*p != '[') return NULL;
+    p++;
+    ha_json_node_t *arr = new_node(HA_JSON_ARRAY);
+    if (!arr) return NULL;
+    ha_json_node_t **tail = &arr->child;
+    p = skip_ws(p);
+    if (*p == ']') { *pp = p + 1; return arr; }
+    while (*p) {
+        ha_json_node_t *val = parse_value(&p);
+        if (!val) break;
+        *tail = val;
+        tail = &val->next;
+        p = skip_ws(p);
+        if (*p == ',') { p++; continue; }
+        if (*p == ']') break;
+    }
+    p = skip_ws(p);
+    if (*p == ']') { *pp = p + 1; return arr; }
+    ha_json_free(arr);
+    return NULL;
+}
+
+/* 解析值（主入口） */
+static ha_json_node_t *parse_value(const char **pp) {
+    const char *p = skip_ws(*pp);
+    if (*p == '{') return parse_object(pp);
+    if (*p == '[') return parse_array(pp);
+    if (*p == '"') {
+        char *s = parse_string(pp);
+        if (!s) return NULL;
+        ha_json_node_t *n = new_node(HA_JSON_STRING);
+        if (!n) { free(s); return NULL; }
+        n->str_val = s;
+        return n;
+    }
+    if (*p == '-' || isdigit((unsigned char)*p)) return parse_number(pp);
+    return parse_keyword(pp);
+}
+
+/* ======================== 公共 API ======================== */
+
+ha_json_node_t *ha_json_parse(const char *str) {
+    if (!str) return NULL;
+    const char *p = str;
+    return parse_value(&p);
+}
+
+const char *ha_json_get_string(const ha_json_node_t *obj, const char *key) {
+    ha_json_node_t *n = ha_json_get(obj, key);
+    if (!n || n->type != HA_JSON_STRING) return NULL;
+    return n->str_val;
+}
+
+int ha_json_get_int(const ha_json_node_t *obj, const char *key, int def) {
+    ha_json_node_t *n = ha_json_get(obj, key);
+    if (!n || n->type != HA_JSON_INT) return def;
+    return n->int_val;
+}
+
+ha_json_node_t *ha_json_get(const ha_json_node_t *obj, const char *key) {
+    if (!obj || obj->type != HA_JSON_OBJECT) return NULL;
+    ha_json_node_t *c = obj->child;
+    while (c) {
+        if (c->key && strcmp(c->key, key) == 0) return c;
+        c = c->next;
+    }
+    return NULL;
+}
+
+int ha_json_array_len(const ha_json_node_t *arr) {
+    if (!arr || arr->type != HA_JSON_ARRAY) return 0;
+    int n = 0;
+    ha_json_node_t *c = arr->child;
+    while (c) { n++; c = c->next; }
+    return n;
+}
+
+ha_json_node_t *ha_json_array_get(const ha_json_node_t *arr, int index) {
+    if (!arr || arr->type != HA_JSON_ARRAY) return NULL;
+    ha_json_node_t *c = arr->child;
+    int i = 0;
+    while (c) {
+        if (i == index) return c;
+        i++; c = c->next;
+    }
+    return NULL;
+}
+
+void ha_json_free(ha_json_node_t *root) {
+    if (!root) return;
+    ha_json_node_t *c = root->child;
+    while (c) {
+        ha_json_node_t *next = c->next;
+        free(c->key);
+        if (c->type == HA_JSON_STRING) free(c->str_val);
+        ha_json_free(c);
+        c = next;
+    }
+    free(root);
+}
+
+/* ======================== 构建器 ======================== */
+
+static void json_escape(ha_json_builder_t *jb, const char *s) {
+    if (!s) { ha_json_builder_raw(jb, "null"); return; }
+    ha_json_builder_raw(jb, "\"");
+    for (const char *p = s; *p; p++) {
+        unsigned char c = (unsigned char)*p;
+        switch (c) {
+            case '"':  ha_json_builder_raw(jb, "\\\""); break;
+            case '\\': ha_json_builder_raw(jb, "\\\\"); break;
+            case '\b': ha_json_builder_raw(jb, "\\b"); break;
+            case '\f': ha_json_builder_raw(jb, "\\f"); break;
+            case '\n': ha_json_builder_raw(jb, "\\n"); break;
+            case '\r': ha_json_builder_raw(jb, "\\r"); break;
+            case '\t': ha_json_builder_raw(jb, "\\t"); break;
+            default:
+                if (c < 0x20) {
+                    char buf[8];
+                    snprintf(buf, sizeof(buf), "\\u%04x", c);
+                    ha_json_builder_raw(jb, buf);
+                } else {
+                    char buf[2] = { (char)c, 0 };
+                    ha_json_builder_raw(jb, buf);
+                }
+                break;
+        }
+    }
+    ha_json_builder_raw(jb, "\"");
+}
+
+void ha_json_builder_init(ha_json_builder_t *jb, char *buf, int cap) {
+    jb->buf = buf;
+    jb->len = 0;
+    jb->cap = cap;
+    jb->depth = 0;
+    if (cap > 0) buf[0] = '\0';
+}
+
+void ha_json_builder_reset(ha_json_builder_t *jb) {
+    jb->len = 0;
+    jb->depth = 0;
+    if (jb->cap > 0) jb->buf[0] = '\0';
+}
+
+void ha_json_builder_raw(ha_json_builder_t *jb, const char *s) {
+    while (*s && jb->len < jb->cap - 1) {
+        jb->buf[jb->len++] = *s++;
+    }
+    jb->buf[jb->len] = '\0';
+}
+
+void ha_json_builder_comma(ha_json_builder_t *jb) {
+    if (jb->depth > 0 && jb->item_count[jb->depth - 1] > 0) {
+        ha_json_builder_raw(jb, ",");
+    }
+    if (jb->depth > 0) jb->item_count[jb->depth - 1]++;
+}
+
+void ha_json_builder_begin_object(ha_json_builder_t *jb) {
+    ha_json_builder_comma(jb);
+    ha_json_builder_raw(jb, "{");
+    if (jb->depth < 16) jb->item_count[jb->depth] = 0;
+    jb->depth++;
+}
+
+void ha_json_builder_end_object(ha_json_builder_t *jb) {
+    jb->depth--;
+    ha_json_builder_raw(jb, "}");
+}
+
+void ha_json_builder_begin_array(ha_json_builder_t *jb) {
+    ha_json_builder_comma(jb);
+    ha_json_builder_raw(jb, "[");
+    if (jb->depth < 16) jb->item_count[jb->depth] = 0;
+    jb->depth++;
+}
+
+void ha_json_builder_end_array(ha_json_builder_t *jb) {
+    jb->depth--;
+    ha_json_builder_raw(jb, "]");
+}
+
+void ha_json_builder_key(ha_json_builder_t *jb, const char *key) {
+    ha_json_builder_comma(jb);
+    json_escape(jb, key);
+    ha_json_builder_raw(jb, ":");
+}
+
+void ha_json_builder_add_string(ha_json_builder_t *jb, const char *val) {
+    json_escape(jb, val);
+}
+
+void ha_json_builder_add_int(ha_json_builder_t *jb, int val) {
+    char buf[16];
+    snprintf(buf, sizeof(buf), "%d", val);
+    ha_json_builder_raw(jb, buf);
+}
+
+void ha_json_builder_add_bool(ha_json_builder_t *jb, int val) {
+    ha_json_builder_raw(jb, val ? "true" : "false");
+}
+
+void ha_json_builder_add_null(ha_json_builder_t *jb) {
+    ha_json_builder_raw(jb, "null");
+}
+
+void ha_json_builder_string(ha_json_builder_t *jb, const char *key, const char *val) {
+    ha_json_builder_key(jb, key);
+    json_escape(jb, val);
+}
+
+void ha_json_builder_int(ha_json_builder_t *jb, const char *key, int val) {
+    ha_json_builder_key(jb, key);
+    ha_json_builder_add_int(jb, val);
+}
+
+void ha_json_builder_bool(ha_json_builder_t *jb, const char *key, int val) {
+    ha_json_builder_key(jb, key);
+    ha_json_builder_add_bool(jb, val);
+}
+
+const char *ha_json_builder_str(ha_json_builder_t *jb) {
+    return jb->buf;
+}
+
+int ha_json_builder_len(ha_json_builder_t *jb) {
+    return jb->len;
+}

remotedevice/src/ha_json.h

@@ -0,0 +1,107 @@
+#ifndef HA_JSON_H
+#define HA_JSON_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ======================== JSON 解析器（DOM 风格） ======================== */
+typedef enum {
+    HA_JSON_NULL,
+    HA_JSON_BOOL,
+    HA_JSON_INT,
+    HA_JSON_STRING,
+    HA_JSON_ARRAY,
+    HA_JSON_OBJECT,
+} ha_json_type_t;
+
+typedef struct ha_json_node {
+    ha_json_type_t       type;
+    union {
+        int              bool_val;
+        int              int_val;
+        char            *str_val;
+    };
+    struct ha_json_node *next;     /* linked list for array/object items */
+    struct ha_json_node *child;    /* first child for array/object */
+    char               *key;       /* key for object members */
+} ha_json_node_t;
+
+/* 解析 JSON 字符串，返回根节点。失败返回 NULL。 */
+ha_json_node_t *ha_json_parse(const char *str);
+
+/* 从对象中按 key 获取字符串值，不存在返回 NULL */
+const char     *ha_json_get_string(const ha_json_node_t *obj, const char *key);
+
+/* 从对象中按 key 获取 int 值，不存在返回 def */
+int             ha_json_get_int(const ha_json_node_t *obj, const char *key, int def);
+
+/* 从对象中按 key 获取子节点，不存在返回 NULL */
+ha_json_node_t *ha_json_get(const ha_json_node_t *obj, const char *key);
+
+/* 获取数组长度 */
+int             ha_json_array_len(const ha_json_node_t *arr);
+
+/* 获取数组第 index 个元素，越界返回 NULL */
+ha_json_node_t *ha_json_array_get(const ha_json_node_t *arr, int index);
+
+/* 释放整个 JSON 树 */
+void            ha_json_free(ha_json_node_t *root);
+
+/* ======================== JSON 构建器（直接写缓冲区） ======================== */
+typedef struct {
+    char   *buf;
+    int     len;
+    int     cap;
+    int     depth;
+    int     item_count[16];  /* 每层已添加元素数，用于逗号判断 */
+} ha_json_builder_t;
+
+/* 初始化构建器 */
+void ha_json_builder_init(ha_json_builder_t *jb, char *buf, int cap);
+
+/* 清空构建器 */
+void ha_json_builder_reset(ha_json_builder_t *jb);
+
+/* 基础写入 */
+void ha_json_builder_raw(ha_json_builder_t *jb, const char *s);
+
+/* 逗号（自动判断是否需要加） */
+void ha_json_builder_comma(ha_json_builder_t *jb);
+
+/* 对象 */
+void ha_json_builder_begin_object(ha_json_builder_t *jb);
+void ha_json_builder_end_object(ha_json_builder_t *jb);
+
+/* 数组 */
+void ha_json_builder_begin_array(ha_json_builder_t *jb);
+void ha_json_builder_end_array(ha_json_builder_t *jb);
+
+/* 键名 */
+void ha_json_builder_key(ha_json_builder_t *jb, const char *key);
+
+/* 值 */
+void ha_json_builder_add_string(ha_json_builder_t *jb, const char *val);
+void ha_json_builder_add_int(ha_json_builder_t *jb, int val);
+void ha_json_builder_add_bool(ha_json_builder_t *jb, int val);
+void ha_json_builder_add_null(ha_json_builder_t *jb);
+
+/* 快捷方法：直接写 "key":"val" */
+void ha_json_builder_string(ha_json_builder_t *jb, const char *key, const char *val);
+void ha_json_builder_int(ha_json_builder_t *jb, const char *key, int val);
+void ha_json_builder_bool(ha_json_builder_t *jb, const char *key, int val);
+
+/* 获取当前构建的字符串指针 */
+const char *ha_json_builder_str(ha_json_builder_t *jb);
+
+/* 获取当前长度 */
+int         ha_json_builder_len(ha_json_builder_t *jb);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HA_JSON_H */

remotedevice/src/ha_remotedevice.c

@@ -0,0 +1,628 @@
+#include "ha_remotedevice.h"
+#include "ha_json.h"
+#include "ha_ws.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define HA_VERSION "0.1.0"
+
+/* 前向声明（因 handle_cmd_msg 需要调用这些函数，而它们定义在后面） */
+void ha_client_send_result(ha_client_t *client, const char *req_id,
+                           const char *status, const char *output,
+                           const char *error);
+void ha_client_send_data_chunked(ha_client_t *client, const char *req_id,
+                                 const char *kind, const char *mime,
+                                 const uint8_t *data, int len);
+
+/* ======================== 内部状态 ======================== */
+typedef enum {
+    HA_STATE_INIT,
+    HA_STATE_DISCONNECTED,
+    HA_STATE_CONNECTING,
+    HA_STATE_WS_UPGRADING,
+    HA_STATE_HELLO_SENT,
+    HA_STATE_BIND_SENT,
+    HA_STATE_READY,
+    HA_STATE_STOPPING,
+} ha_state_t;
+
+/* 语音数据聚合缓冲区 */
+typedef struct {
+    char     req_id[128];
+    char     kind[64];
+    char     mime[64];
+    int      total;
+    uint8_t *data;
+    int      len;
+    int      cap;
+} ha_speech_accum_t;
+
+struct ha_client {
+    ha_config_t      config;        /* 拷贝的配置 */
+    ha_state_t       state;
+    int              reconnect_cnt; /* 当前重连次数 */
+    ha_ws_t          ws;            /* WS 连接 */
+
+    /* JSON 构建缓冲区 */
+    char             json_buf[4096];
+    ha_json_builder_t jb;
+
+    /* 语音数据聚合 */
+    ha_speech_accum_t speech;
+};
+
+/* ======================== 辅助函数 ======================== */
+
+static void set_sockbuf(ha_client_t *c, int i) { (void)c; (void)i; }
+
+/* Base64 编码表 */
+static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+int ha_base64_encode(const uint8_t *data, int len, char *out, int out_len) {
+    int needed = ((len + 2) / 3) * 4 + 1;
+    if (out_len < needed) {
+        if (out_len > 0) out[0] = '\0';
+        return needed;
+    }
+    int i = 0, j = 0;
+    while (i < len) {
+        int rem = len - i;
+        uint8_t b0 = data[i++];
+        uint8_t b1 = (rem > 1) ? data[i++] : 0;
+        uint8_t b2 = (rem > 2) ? data[i++] : 0;
+        out[j++] = b64[b0 >> 2];
+        out[j++] = b64[((b0 & 0x03) << 4) | (b1 >> 4)];
+        out[j++] = (rem > 1) ? b64[((b1 & 0x0F) << 2) | (b2 >> 6)] : '=';
+        out[j++] = (rem > 2) ? b64[b2 & 0x3F] : '=';
+    }
+    out[j] = '\0';
+    return j;
+}
+
+/* ======================== JSON 构建辅助 ======================== */
+static void json_init(ha_client_t *c) {
+    ha_json_builder_init(&c->jb, c->json_buf, sizeof(c->json_buf));
+}
+
+/* ======================== WS 发送 JSON ======================== */
+static int ws_send_json(ha_client_t *c) {
+    return ha_ws_send_text(&c->ws, c->json_buf);
+}
+
+/* ======================== 协议消息构造 ======================== */
+
+/* 构建 hello 消息 */
+static int send_hello(ha_client_t *c) {
+    json_init(c);
+    ha_json_builder_begin_object(&c->jb);
+    ha_json_builder_string(&c->jb, "op", "hello");
+    ha_json_builder_key(&c->jb, "device");
+    ha_json_builder_begin_object(&c->jb);
+    ha_json_builder_string(&c->jb, "device_id", c->config.device.device_id);
+    ha_json_builder_string(&c->jb, "name", c->config.device.name);
+    ha_json_builder_string(&c->jb, "kind", c->config.device.kind);
+    /* caps */
+    ha_json_builder_key(&c->jb, "caps");
+    ha_json_builder_begin_array(&c->jb);
+    if (c->config.device.caps) {
+        for (const char **p = c->config.device.caps; *p; p++) {
+            ha_json_builder_add_string(&c->jb, *p);
+        }
+    }
+    ha_json_builder_end_array(&c->jb);
+    /* info 可选 */
+    if (c->config.device.info_json && c->config.device.info_json[0]) {
+        ha_json_builder_string(&c->jb, "info", c->config.device.info_json);
+    }
+    ha_json_builder_end_object(&c->jb); /* device */
+    ha_json_builder_end_object(&c->jb); /* root */
+    return ws_send_json(c);
+}
+
+/* 构建 bind 消息 */
+static int send_bind(ha_client_t *c) {
+    json_init(c);
+    ha_json_builder_begin_object(&c->jb);
+    ha_json_builder_string(&c->jb, "op", "bind");
+    ha_json_builder_string(&c->jb, "device_id", c->config.device.device_id);
+    ha_json_builder_string(&c->jb, "token", c->config.token);
+    ha_json_builder_end_object(&c->jb);
+    return ws_send_json(c);
+}
+
+/* ======================== 消息处理 ======================== */
+
+/* 在 handlers 表中查找命令处理函数 */
+static ha_cmd_handler_def_t *find_handler(ha_client_t *c, const char *name) {
+    if (!name || !c->config.handlers) return NULL;
+    for (ha_cmd_handler_def_t *h = c->config.handlers; h->command; h++) {
+        if (strcmp(h->command, name) == 0) return h;
+    }
+    return NULL;
+}
+
+/* 声明式命令分发：查找 handlers 表 → 调用 handler → 自动回执 */
+static void handle_cmd_msg(ha_client_t *c, ha_json_node_t *msg) {
+    const char *req_id = ha_json_get_string(msg, "req_id");
+    const char *command = ha_json_get_string(msg, "command");
+    const char *cmd_type = ha_json_get_string(msg, "cmd_type");
+    if (!req_id || !command) return;
+    if (!cmd_type) cmd_type = "homeagent";
+
+    const char *handler_name = NULL;
+    const char *args = command;
+
+    if (strcmp(cmd_type, "shell") == 0) {
+        handler_name = "shell";
+        /* args 保持为完整命令字符串 */
+    } else {
+        /* homeagent-* 命令：提取能力名作为 handler 名 */
+        const char *cap = command;
+        const char *p = command;
+        if (strncmp(p, "homeagent-", 10) == 0) p += 10;
+        const char *space = strchr(p, ' ');
+        if (space) {
+            args = space + 1;
+            /* handler_name 用静态缓冲区 */
+            static char name_buf[128];
+            int n = (int)(space - p);
+            if (n > 127) n = 127;
+            strncpy(name_buf, p, n);
+            name_buf[n] = '\0';
+            handler_name = name_buf;
+        } else {
+            handler_name = p;
+            args = "";
+        }
+    }
+
+    ha_cmd_handler_def_t *def = find_handler(c, handler_name);
+    if (!def) {
+        ha_client_send_result(c, req_id, "error", NULL,
+                              "unsupported command");
+        return;
+    }
+
+    /* 调用 handler，填写 result */
+    ha_cmd_result_t result;
+    memset(&result, 0, sizeof(result));
+    ha_status_t st = def->handler(req_id, args, &result, c->config.userdata);
+
+    /* 自动回执 */
+    if (st != HA_OK) {
+        ha_client_send_result(c, req_id, "error", NULL,
+                              result.error ? result.error : "handler failed");
+        return;
+    }
+
+    if (result.has_binary && result.binary_data && result.binary_len > 0) {
+        /* 二进制分块回传 */
+        ha_client_send_data_chunked(c, req_id,
+            handler_name, result.binary_mime ? result.binary_mime : "application/octet-stream",
+            result.binary_data, result.binary_len);
+    } else {
+        /* 文本回传 */
+        ha_client_send_result(c, req_id, result.status == 0 ? "ok" : "error",
+                              result.output, result.error);
+    }
+}
+
+static void handle_speech_start(ha_client_t *c, ha_json_node_t *msg) {
+    const char *req_id = ha_json_get_string(msg, "req_id");
+    const char *kind = ha_json_get_string(msg, "kind");
+    const char *mime = ha_json_get_string(msg, "mime");
+    if (!req_id) return;
+
+    /* 释放旧的聚合数据 */
+    free(c->speech.data);
+    memset(&c->speech, 0, sizeof(c->speech));
+
+    strncpy(c->speech.req_id, req_id, sizeof(c->speech.req_id) - 1);
+    if (kind) strncpy(c->speech.kind, kind, sizeof(c->speech.kind) - 1);
+    if (mime) strncpy(c->speech.mime, mime, sizeof(c->speech.mime) - 1);
+    c->speech.total = ha_json_get_int(msg, "total", 0);
+}
+
+static void handle_speech_end(ha_client_t *c, ha_json_node_t *msg) {
+    const char *req_id = ha_json_get_string(msg, "req_id");
+    if (!req_id || strcmp(req_id, c->speech.req_id) != 0) return;
+
+    if (c->config.on_binary && c->speech.data && c->speech.len > 0) {
+        c->config.on_binary(c->speech.req_id, c->speech.kind,
+                            c->speech.mime, c->speech.data,
+                            c->speech.len, c->config.userdata);
+    }
+
+    free(c->speech.data);
+    memset(&c->speech, 0, sizeof(c->speech));
+}
+
+static void handle_text_message(ha_client_t *c, const uint8_t *payload, int len) {
+    /* 解析 JSON */
+    char *tmp = (char *)malloc(len + 1);
+    if (!tmp) return;
+    memcpy(tmp, payload, len);
+    tmp[len] = '\0';
+
+    ha_json_node_t *root = ha_json_parse(tmp);
+    if (!root) { free(tmp); return; }
+
+    const char *op = ha_json_get_string(root, "op");
+    if (!op) { ha_json_free(root); free(tmp); return; }
+
+    switch (c->state) {
+        case HA_STATE_HELLO_SENT:
+            if (strcmp(op, "hello_ack") == 0) {
+                c->state = HA_STATE_BIND_SENT;
+                send_bind(c);
+            }
+            break;
+        case HA_STATE_BIND_SENT:
+            if (strcmp(op, "bind_ack") == 0) {
+                c->state = HA_STATE_READY;
+                if (c->config.on_state) {
+                    c->config.on_state(1, c->config.userdata);
+                }
+            }
+            break;
+        case HA_STATE_READY:
+            if (strcmp(op, "cmd") == 0) {
+                handle_cmd_msg(c, root);
+            } else if (strcmp(op, "cmd_speech_start") == 0) {
+                handle_speech_start(c, root);
+            } else if (strcmp(op, "cmd_speech_end") == 0) {
+                handle_speech_end(c, root);
+            }
+            break;
+        default:
+            break;
+    }
+
+    ha_json_free(root);
+    free(tmp);
+}
+
+/* ======================== 连接管理 ======================== */
+
+static int do_connect(ha_client_t *c) {
+    c->state = HA_STATE_CONNECTING;
+    c->reconnect_cnt++;
+
+    /* 解析 server 地址 */
+    char host[256] = {0};
+    uint16_t port = 9890;
+    const char *p = c->config.server;
+    if (!p) return -1;
+
+    /* 去掉 ws:// 前缀 */
+    if (strncmp(p, "ws://", 5) == 0) p += 5;
+    else if (strncmp(p, "wss://", 6) == 0) p += 6;
+
+    /* 提取 host:port */
+    const char *colon = strchr(p, ':');
+    const char *slash = strchr(p, '/');
+    if (colon && (!slash || colon < slash)) {
+        int host_len = (int)(colon - p);
+        if (host_len > (int)sizeof(host) - 1) host_len = sizeof(host) - 1;
+        memcpy(host, p, host_len);
+        host[host_len] = '\0';
+        port = (uint16_t)atoi(colon + 1);
+    } else {
+        int host_len = (slash ? (int)(slash - p) : (int)strlen(p));
+        if (host_len > (int)sizeof(host) - 1) host_len = sizeof(host) - 1;
+        memcpy(host, p, host_len);
+        host[host_len] = '\0';
+    }
+
+    c->state = HA_STATE_WS_UPGRADING;
+    if (ha_ws_connect(&c->ws, &c->config.transport, host, port,
+                      "/api/v1/device/ws", c->config.token) != 0) {
+        c->state = HA_STATE_DISCONNECTED;
+        return -1;
+    }
+
+    /* 发送 hello */
+    c->state = HA_STATE_HELLO_SENT;
+    if (send_hello(c) != 0) {
+        ha_ws_close(&c->ws);
+        c->state = HA_STATE_DISCONNECTED;
+        return -1;
+    }
+
+    return 0;
+}
+
+/* ======================== 公共 API ======================== */
+
+ha_client_t *ha_client_new(const ha_config_t *config) {
+    ha_client_t *c = (ha_client_t *)calloc(1, sizeof(ha_client_t));
+    if (!c) return NULL;
+    memcpy(&c->config, config, sizeof(ha_config_t));
+    c->state = HA_STATE_INIT;
+    c->reconnect_cnt = 0;
+    return c;
+}
+
+ha_status_t ha_client_start(ha_client_t *client) {
+    if (!client) return HA_ERR_INVALID;
+    if (client->state != HA_STATE_INIT) return HA_ERR_GENERIC;
+
+    /* 默认心跳间隔 30 秒 */
+    if (client->config.ping_interval <= 0) {
+        client->config.ping_interval = 30;
+    }
+
+    if (do_connect(client) != 0) {
+        return HA_ERR_TRANSPORT;
+    }
+
+    /* 等待 bind_ack（最多 5 秒） */
+    int wait_ms = 5000;
+    int step = 50;
+    while (wait_ms > 0 && client->state != HA_STATE_READY) {
+        /* 处理一帧 */
+        ha_status_t st = ha_client_process(client);
+        if (st != HA_OK && st != HA_ERR_DISCONNECTED) {
+            return st;
+        }
+        if (client->state == HA_STATE_READY) return HA_OK;
+
+        /* 简单延时：靠 process 中的 recv 阻塞 */
+        wait_ms -= step;
+    }
+
+    return (client->state == HA_STATE_READY) ? HA_OK : HA_ERR_TIMEOUT;
+}
+
+ha_status_t ha_client_process(ha_client_t *client) {
+    if (!client) return HA_ERR_INVALID;
+
+    if (client->state == HA_STATE_STOPPING) {
+        return HA_ERR_DISCONNECTED;
+    }
+
+    /* 断线重连 */
+    if (client->state == HA_STATE_DISCONNECTED ||
+        client->state == HA_STATE_INIT) {
+        if (client->config.max_reconnect >= 0 &&
+            client->reconnect_cnt > client->config.max_reconnect) {
+            return HA_ERR_DISCONNECTED;
+        }
+        /* 非阻塞模式：不在这里阻塞等待重连，返回 HA_ERR_DISCONNECTED */
+        return HA_ERR_DISCONNECTED;
+    }
+
+    if (!client->ws.connected) {
+        client->state = HA_STATE_DISCONNECTED;
+        if (client->config.on_state) {
+            client->config.on_state(0, client->config.userdata);
+        }
+        return HA_ERR_DISCONNECTED;
+    }
+
+    /* 尝试读取一帧 */
+    const uint8_t *payload = NULL;
+    int len = 0;
+    int ret = ha_ws_read_frame(&client->ws, &payload, &len);
+
+    if (ret < 0) {
+        /* 连接断开 */
+        client->state = HA_STATE_DISCONNECTED;
+        if (client->config.on_state) {
+            client->config.on_state(0, client->config.userdata);
+        }
+        return HA_ERR_DISCONNECTED;
+    }
+
+    switch (ret) {
+        case WS_OPCODE_TEXT:
+            handle_text_message(client, payload, len);
+            break;
+        case WS_OPCODE_BINARY:
+            /* 二进制帧：如果处于语音聚合状态，追加数据 */
+            if (client->speech.req_id[0] && payload) {
+                int new_len = client->speech.len + len;
+                if (new_len > client->speech.cap) {
+                    int new_cap = client->speech.cap ? client->speech.cap * 2 : 4096;
+                    while (new_cap < new_len) new_cap *= 2;
+                    uint8_t *nd = (uint8_t *)realloc(client->speech.data, new_cap);
+                    if (!nd) break;
+                    client->speech.data = nd;
+                    client->speech.cap = new_cap;
+                }
+                memcpy(client->speech.data + client->speech.len, payload, len);
+                client->speech.len = new_len;
+            }
+            break;
+        case WS_OPCODE_PING:
+            /* 回复 pong */
+            ha_ws_send_frame(&client->ws, WS_OPCODE_PONG, NULL, 0);
+            break;
+        case WS_OPCODE_PONG:
+            /* 收到 pong，忽略 */
+            break;
+        case WS_OPCODE_CLOSE:
+            client->state = HA_STATE_DISCONNECTED;
+            if (client->config.on_state) {
+                client->config.on_state(0, client->config.userdata);
+            }
+            return HA_ERR_DISCONNECTED;
+    }
+
+    return HA_OK;
+}
+
+void ha_client_send_result(ha_client_t *client, const char *req_id,
+                           const char *status, const char *output,
+                           const char *error) {
+    if (!client || client->state != HA_STATE_READY) return;
+    json_init(client);
+    ha_json_builder_begin_object(&client->jb);
+    ha_json_builder_string(&client->jb, "op", "cmd_result");
+    ha_json_builder_string(&client->jb, "req_id", req_id);
+    ha_json_builder_string(&client->jb, "status", status ? status : "ok");
+    ha_json_builder_string(&client->jb, "device_id", client->config.device.device_id);
+    if (output && output[0]) {
+        ha_json_builder_string(&client->jb, "output", output);
+    }
+    if (error && error[0]) {
+        ha_json_builder_string(&client->jb, "error", error);
+    }
+    ha_json_builder_end_object(&client->jb);
+    ws_send_json(client);
+}
+
+void ha_client_send_data_chunked(ha_client_t *client, const char *req_id,
+                                 const char *kind, const char *mime,
+                                 const uint8_t *data, int len) {
+    if (!client || client->state != HA_STATE_READY) return;
+
+    /* cmd_data_start */
+    json_init(client);
+    ha_json_builder_begin_object(&client->jb);
+    ha_json_builder_string(&client->jb, "op", "cmd_data_start");
+    ha_json_builder_string(&client->jb, "req_id", req_id);
+    ha_json_builder_string(&client->jb, "kind", kind ? kind : "data");
+    ha_json_builder_string(&client->jb, "mime", mime ? mime : "application/octet-stream");
+    ha_json_builder_int(&client->jb, "total", len);
+    ha_json_builder_int(&client->jb, "chunk_size", 8192);
+    ha_json_builder_end_object(&client->jb);
+    ws_send_json(client);
+
+    /* 二进制帧分块发送 */
+    int off = 0;
+    while (off < len) {
+        int chunk = len - off;
+        if (chunk > 8192) chunk = 8192;
+        if (ha_ws_send_binary(&client->ws, data + off, chunk) != 0) return;
+        off += chunk;
+    }
+
+    /* cmd_data_end */
+    json_init(client);
+    ha_json_builder_begin_object(&client->jb);
+    ha_json_builder_string(&client->jb, "op", "cmd_data_end");
+    ha_json_builder_string(&client->jb, "req_id", req_id);
+    ha_json_builder_string(&client->jb, "status", "ok");
+    ha_json_builder_int(&client->jb, "total", len);
+    ha_json_builder_end_object(&client->jb);
+    ws_send_json(client);
+}
+
+void ha_client_send_event(ha_client_t *client, const char *type,
+                          const char *detail) {
+    if (!client || client->state != HA_STATE_READY) return;
+    json_init(client);
+    ha_json_builder_begin_object(&client->jb);
+    ha_json_builder_string(&client->jb, "op", "event");
+    ha_json_builder_string(&client->jb, "device_id", client->config.device.device_id);
+    ha_json_builder_string(&client->jb, "type", type ? type : "");
+    if (detail && detail[0]) {
+        ha_json_builder_string(&client->jb, "payload", detail);
+    }
+    ha_json_builder_end_object(&client->jb);
+    ws_send_json(client);
+}
+
+void ha_client_send_status(ha_client_t *client, const char *status) {
+    if (!client || client->state != HA_STATE_READY) return;
+    json_init(client);
+    ha_json_builder_begin_object(&client->jb);
+    ha_json_builder_string(&client->jb, "op", "status");
+    ha_json_builder_string(&client->jb, "device_id", client->config.device.device_id);
+    ha_json_builder_string(&client->jb, "status", status ? status : "online");
+    ha_json_builder_end_object(&client->jb);
+    ws_send_json(client);
+}
+
+void ha_client_stop(ha_client_t *client) {
+    if (!client) return;
+    client->state = HA_STATE_STOPPING;
+    if (client->ws.connected) {
+        ha_ws_close(&client->ws);
+    }
+}
+
+void ha_client_destroy(ha_client_t *client) {
+    if (!client) return;
+    ha_client_stop(client);
+    free(client->speech.data);
+    free(client);
+}
+
+/* ======================== 工具函数 ======================== */
+
+void ha_cmd_parse_homeagent(const char *command, const char **cap,
+                            const char **args) {
+    *cap = command;
+    *args = "";
+
+    if (!command) {
+        *cap = "";
+        return;
+    }
+
+    /* 去掉 homeagent- 前缀 */
+    const char *p = command;
+    if (strncmp(p, "homeagent-", 10) == 0) {
+        p += 10;
+    }
+
+    /* 按空格分割 */
+    const char *space = strchr(p, ' ');
+    if (space) {
+        /* cap 指向 p 但不包含空格，需要临时拷贝 */
+        /* 返回指针到原始字符串，调用方用 strncpy 取出 */
+        *cap = command; /* 调用方应使用 ha_cmd_parse_homeagent 的要小心 */
+        /* 实际上，最简单的方式是原地修改，但 const 不允许 */
+        /* 用静态缓冲区或让调用方自己处理 */
+        static char cap_buf[256];
+        int n = (int)(space - p);
+        if (n > 255) n = 255;
+        strncpy(cap_buf, p, n);
+        cap_buf[n] = '\0';
+        *cap = cap_buf;
+        *args = space + 1;
+    } else {
+        static char cap_buf[256];
+        strncpy(cap_buf, p, sizeof(cap_buf) - 1);
+        cap_buf[sizeof(cap_buf) - 1] = '\0';
+        *cap = cap_buf;
+        *args = "";
+    }
+}
+
+void ha_cmd_parse_json(const char *command, const char **action,
+                       const char **json_str) {
+    *action = "";
+    *json_str = "";
+
+    if (!command) return;
+
+    const char *p = command;
+    if (strncmp(p, "homeagent-", 10) == 0) {
+        p += 10;
+    }
+
+    const char *brace = strchr(p, '{');
+    if (brace) {
+        static char act_buf[256];
+        int n = (int)(brace - p);
+        while (n > 0 && (p[n - 1] == ' ' || p[n - 1] == '\t')) n--;
+        if (n > 255) n = 255;
+        strncpy(act_buf, p, n);
+        act_buf[n] = '\0';
+        *action = act_buf;
+        *json_str = brace;
+    } else {
+        static char act_buf[256];
+        strncpy(act_buf, p, sizeof(act_buf) - 1);
+        *action = act_buf;
+    }
+}
+
+const char *ha_version(void) {
+    return HA_VERSION;
+}
+

remotedevice/src/ha_ws.c

@@ -0,0 +1,325 @@
+#include "ha_ws.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* WS GUID 用于计算 Accept 值 */
+#define WS_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+/* ======================== Base64 编码（用于 WS key） ======================== */
+static const char b64t[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static void base64_encode_bin(const uint8_t *in, int in_len, char *out) {
+    int i = 0, j = 0;
+    uint8_t b[3];
+    while (i < in_len) {
+        int rem = in_len - i;
+        if (rem >= 3) {
+            b[0] = in[i++]; b[1] = in[i++]; b[2] = in[i++];
+            out[j++] = b64t[b[0] >> 2];
+            out[j++] = b64t[((b[0] & 0x03) << 4) | (b[1] >> 4)];
+            out[j++] = b64t[((b[1] & 0x0F) << 2) | (b[2] >> 6)];
+            out[j++] = b64t[b[2] & 0x3F];
+        } else if (rem == 2) {
+            b[0] = in[i++]; b[1] = in[i++];
+            out[j++] = b64t[b[0] >> 2];
+            out[j++] = b64t[((b[0] & 0x03) << 4) | (b[1] >> 4)];
+            out[j++] = b64t[(b[1] & 0x0F) << 2];
+            out[j++] = '=';
+        } else {
+            b[0] = in[i++];
+            out[j++] = b64t[b[0] >> 2];
+            out[j++] = b64t[(b[0] & 0x03) << 4];
+            out[j++] = '=';
+            out[j++] = '=';
+        }
+    }
+    out[j] = '\0';
+}
+
+/* 简单伪随机数生成器 */
+static uint32_t ws_rand_state = 0;
+static void ws_rand_seed(uint32_t seed) { ws_rand_state = seed; }
+static uint32_t ws_rand(void) {
+    ws_rand_state = ws_rand_state * 1103515245 + 12345;
+    return ws_rand_state;
+}
+
+/* 生成 WS 握手 key */
+static void ws_gen_key(char *out) {
+    uint8_t buf[16];
+    for (int i = 0; i < 16; i++) {
+        buf[i] = (uint8_t)(ws_rand() & 0xFF);
+    }
+    base64_encode_bin(buf, 16, out);
+}
+
+/* ======================== 从传输层接收指定字节数 ======================== */
+static int recv_all(ha_ws_t *ws, uint8_t *buf, int len) {
+    int pos = 0;
+    while (pos < len) {
+        int n = ws->transport->recv(ws->transport->ctx, buf + pos, len - pos);
+        if (n <= 0) return -1;
+        pos += n;
+    }
+    return 0;
+}
+
+/* ======================== 发送 WS 帧 ======================== */
+int ha_ws_send_frame(ha_ws_t *ws, int opcode, const uint8_t *payload, int len) {
+    uint8_t hdr[14]; /* 最大帧头：2 + 8 + 4 = 14 */
+    int hdr_len = 0;
+
+    hdr[0] = 0x80 | opcode; /* FIN + opcode */
+    hdr_len = 2;
+
+    int ext_len = 0;
+    if (len < 126) {
+        hdr[1] = 0x80 | len; /* mask bit + length */
+    } else if (len < 65536) {
+        hdr[1] = 0x80 | 126;
+        hdr_len = 4;
+        hdr[2] = (uint8_t)(len >> 8);
+        hdr[3] = (uint8_t)(len & 0xFF);
+        ext_len = 2;
+    } else {
+        hdr[1] = 0x80 | 127;
+        hdr_len = 10;
+        uint64_t l = (uint64_t)len;
+        for (int i = 8; i > 0; i--) {
+            hdr[1 + i] = (uint8_t)(l & 0xFF);
+            l >>= 8;
+        }
+        ext_len = 8;
+    }
+
+    /* mask key */
+    uint8_t mask_key[4];
+    mask_key[0] = (uint8_t)(ws_rand() & 0xFF);
+    mask_key[1] = (uint8_t)(ws_rand() & 0xFF);
+    mask_key[2] = (uint8_t)(ws_rand() & 0xFF);
+    mask_key[3] = (uint8_t)(ws_rand() & 0xFF);
+
+    int mask_off = 2 + ext_len;
+    hdr[mask_off]     = mask_key[0];
+    hdr[mask_off + 1] = mask_key[1];
+    hdr[mask_off + 2] = mask_key[2];
+    hdr[mask_off + 3] = mask_key[3];
+    hdr_len = mask_off + 4;
+
+    /* 发送帧头 */
+    if (ws->transport->send(ws->transport->ctx, hdr, hdr_len) != hdr_len) {
+        return -1;
+    }
+
+    /* 发送掩码后的 payload */
+    if (len > 0) {
+        /* 如果 payload 不大，用栈缓冲区 */
+        uint8_t stack_buf[2048];
+        uint8_t *masked = (len <= (int)sizeof(stack_buf)) ? stack_buf : (uint8_t *)malloc(len);
+        if (!masked) return -1;
+
+        for (int i = 0; i < len; i++) {
+            masked[i] = payload[i] ^ mask_key[i & 3];
+        }
+
+        int ret = (ws->transport->send(ws->transport->ctx, masked, len) == len) ? 0 : -1;
+
+        if (masked != stack_buf) free(masked);
+        if (ret != 0) return -1;
+    }
+
+    return 0;
+}
+
+/* ======================== 公共 API ======================== */
+
+int ha_ws_connect(ha_ws_t *ws, ha_transport_t *transport,
+                  const char *host, uint16_t port,
+                  const char *path, const char *token) {
+    memset(ws, 0, sizeof(ha_ws_t));
+    ws->transport = transport;
+    ws->connected = 0;
+
+    strncpy(ws->host, host, sizeof(ws->host) - 1);
+    ws->port = port;
+    strncpy(ws->path, path, sizeof(ws->path) - 1);
+    if (token) strncpy(ws->token, token, sizeof(ws->token) - 1);
+
+    /* 种子 */
+    ws_rand_seed((uint32_t)(uintptr_t)ws ^ (uint32_t)port);
+
+    /* 1. TCP 连接 */
+    if (transport->connect(transport->ctx, host, port) != 0) {
+        return -1;
+    }
+
+    /* 2. 发送 WS 升级请求 */
+    char key[32];
+    ws_gen_key(key);
+
+    char req[1024];
+    int n = snprintf(req, sizeof(req),
+        "GET %s HTTP/1.1\r\n"
+        "Host: %s:%u\r\n"
+        "Upgrade: websocket\r\n"
+        "Connection: Upgrade\r\n"
+        "Sec-WebSocket-Key: %s\r\n"
+        "Sec-WebSocket-Version: 13\r\n"
+        "\r\n",
+        path, host, (unsigned)port, key);
+
+    /* 如果 token 存在，加到路径参数中 */
+    if (token && token[0]) {
+        n = snprintf(req, sizeof(req),
+            "GET %s?token=%s HTTP/1.1\r\n"
+            "Host: %s:%u\r\n"
+            "Upgrade: websocket\r\n"
+            "Connection: Upgrade\r\n"
+            "Sec-WebSocket-Key: %s\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+            "\r\n",
+            path, token, host, (unsigned)port, key);
+    }
+
+    if (transport->send(transport->ctx, (uint8_t *)req, n) != n) {
+        transport->close(transport->ctx);
+        return -1;
+    }
+
+    /* 3. 读取响应头（直到 \r\n\r\n） */
+    char resp[1024];
+    int resp_len = 0;
+    int found = 0;
+    while (resp_len < (int)sizeof(resp) - 1) {
+        int n = transport->recv(transport->ctx, (uint8_t *)(resp + resp_len), 1);
+        if (n <= 0) {
+            transport->close(transport->ctx);
+            return -1;
+        }
+        resp_len += n;
+        resp[resp_len] = '\0';
+        if (resp_len >= 4 && strcmp(resp + resp_len - 4, "\r\n\r\n") == 0) {
+            found = 1;
+            break;
+        }
+    }
+    if (!found) {
+        transport->close(transport->ctx);
+        return -1;
+    }
+
+    /* 4. 检查状态码 101 */
+    if (strstr(resp, " 101 ") == NULL) {
+        transport->close(transport->ctx);
+        return -1;
+    }
+
+    ws->connected = 1;
+    return 0;
+}
+
+int ha_ws_send_text(ha_ws_t *ws, const char *text) {
+    if (!ws->connected) return -1;
+    return ha_ws_send_frame(ws, WS_OPCODE_TEXT, (const uint8_t *)text, (int)strlen(text));
+}
+
+int ha_ws_send_binary(ha_ws_t *ws, const uint8_t *data, int len) {
+    if (!ws->connected) return -1;
+    return ha_ws_send_frame(ws, WS_OPCODE_BINARY, data, len);
+}
+
+int ha_ws_send_ping(ha_ws_t *ws) {
+    if (!ws->connected) return -1;
+    return ha_ws_send_frame(ws, WS_OPCODE_PING, NULL, 0);
+}
+
+int ha_ws_read_frame(ha_ws_t *ws, const uint8_t **payload, int *len) {
+    if (!ws->connected) return -1;
+
+    *payload = NULL;
+    *len = 0;
+
+    /* 读取帧头：2 字节 */
+    uint8_t hdr[2];
+    if (recv_all(ws, hdr, 2) != 0) {
+        ws->connected = 0;
+        return -1;
+    }
+
+    int opcode = hdr[0] & 0x0F;
+    int masked = (hdr[1] & 0x80) ? 1 : 0;
+    uint64_t frame_len = hdr[1] & 0x7F;
+
+    if (frame_len == 126) {
+        uint8_t ext[2];
+        if (recv_all(ws, ext, 2) != 0) { ws->connected = 0; return -1; }
+        frame_len = ((uint64_t)ext[0] << 8) | ext[1];
+    } else if (frame_len == 127) {
+        uint8_t ext[8];
+        if (recv_all(ws, ext, 8) != 0) { ws->connected = 0; return -1; }
+        frame_len = 0;
+        for (int i = 0; i < 8; i++) {
+            frame_len = (frame_len << 8) | ext[i];
+        }
+    }
+
+    /* 读取 mask key */
+    uint8_t mask_key[4] = {0, 0, 0, 0};
+    if (masked) {
+        if (recv_all(ws, mask_key, 4) != 0) { ws->connected = 0; return -1; }
+    }
+
+    /* 限制帧大小 */
+    if (frame_len > sizeof(ws->read_buf)) {
+        /* 帧太大，跳过 payload */
+        uint64_t skip = frame_len;
+        uint8_t tmp[256];
+        while (skip > 0) {
+            int to_skip = (skip > sizeof(tmp)) ? (int)sizeof(tmp) : (int)skip;
+            if (recv_all(ws, tmp, to_skip) != 0) { ws->connected = 0; return -1; }
+            skip -= to_skip;
+        }
+        return -1; /* 返回错误，帧太大 */
+    }
+
+    /* 读取 payload */
+    if (frame_len > 0) {
+        if (recv_all(ws, ws->read_buf, (int)frame_len) != 0) {
+            ws->connected = 0;
+            return -1;
+        }
+        /* 如果有 mask，解掩码 */
+        if (masked) {
+            for (uint64_t i = 0; i < frame_len; i++) {
+                ws->read_buf[i] ^= mask_key[i & 3];
+            }
+        }
+    }
+
+    *payload = ws->read_buf;
+    *len = (int)frame_len;
+
+    switch (opcode) {
+        case WS_OPCODE_CLOSE:
+            ws->connected = 0;
+            return WS_OPCODE_CLOSE;
+        case WS_OPCODE_PING:
+            return WS_OPCODE_PING;
+        case WS_OPCODE_PONG:
+            return WS_OPCODE_PONG;
+        case WS_OPCODE_TEXT:
+        case WS_OPCODE_BINARY:
+            return opcode;
+        default:
+            return -1;
+    }
+}
+
+void ha_ws_close(ha_ws_t *ws) {
+    if (ws->connected) {
+        ha_ws_send_frame(ws, WS_OPCODE_CLOSE, NULL, 0);
+        ws->connected = 0;
+    }
+    ws->transport->close(ws->transport->ctx);
+}

remotedevice/src/ha_ws.h

@@ -0,0 +1,62 @@
+#ifndef HA_WS_H
+#define HA_WS_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "../include/ha_remotedevice.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ======================== WS 帧类型 ======================== */
+#define WS_OPCODE_CONTINUATION  0x0
+#define WS_OPCODE_TEXT          0x1
+#define WS_OPCODE_BINARY        0x2
+#define WS_OPCODE_CLOSE         0x8
+#define WS_OPCODE_PING          0x9
+#define WS_OPCODE_PONG          0xA
+
+/* ======================== WS 连接 ======================== */
+typedef struct {
+    ha_transport_t *transport;   /* 用户实现的传输层 */
+    int             connected;   /* 是否已连接 */
+    uint8_t         read_buf[8192];  /* 读缓冲区 */
+    int             read_pos;    /* 缓冲区中有效数据起始位置 */
+    int             read_len;    /* 缓冲区中有效数据长度 */
+    char            host[256];   /* 缓存目标地址 */
+    uint16_t        port;
+    char            path[256];
+    char            token[256];
+} ha_ws_t;
+
+/* 创建 WS 连接。返回 0 成功，非 0 失败。 */
+int  ha_ws_connect(ha_ws_t *ws, ha_transport_t *transport,
+                   const char *host, uint16_t port,
+                   const char *path, const char *token);
+
+/* 发送文本帧。返回 0 成功。 */
+int  ha_ws_send_text(ha_ws_t *ws, const char *text);
+
+/* 发送二进制帧。返回 0 成功。 */
+int  ha_ws_send_binary(ha_ws_t *ws, const uint8_t *data, int len);
+
+/* 发送 ping。返回 0 成功。 */
+int  ha_ws_send_ping(ha_ws_t *ws);
+
+/* 读取一帧。
+ * 返回 opcode (0x1/0x2/0x8/0x9/0xA)，-1 表示关闭或错误。
+ * payload 和 len 指向内部缓冲区，在下次调用前有效。 */
+int  ha_ws_read_frame(ha_ws_t *ws, const uint8_t **payload, int *len);
+
+/* 发送原始 WS 帧（内部使用，用于回复 ping） */
+int  ha_ws_send_frame(ha_ws_t *ws, int opcode, const uint8_t *payload, int len);
+
+/* 关闭 WS 连接 */
+void ha_ws_close(ha_ws_t *ws);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HA_WS_H */

sdk/memory.go

@@ -25,13 +25,18 @@ type Relation struct {
 }
 
 // Triple represents a subject-relation-object triple for the knowledge graph.
+//
+// SentenceText 是这条三元组的原句，会写进 sentences 表；媒体引用挂在句子上，
+// 所以 MediaDigests 非空时内核会保证句子存在（不给就自动合成一句）。
 type Triple struct {
-	Subject     string  `json:"subject"`
-	Relation    string  `json:"relation"`
-	Object      string  `json:"object"`
-	Confidence  float64 `json:"confidence,omitempty"`
-	SubjectType string  `json:"subject_type,omitempty"`
-	ObjectType  string  `json:"object_type,omitempty"`
+	Subject      string   `json:"subject"`
+	Relation     string   `json:"relation"`
+	Object       string   `json:"object"`
+	Confidence   float64  `json:"confidence,omitempty"`
+	SubjectType  string   `json:"subject_type,omitempty"`
+	ObjectType   string   `json:"object_type,omitempty"`
+	SentenceText string   `json:"sentence_text,omitempty"`
+	MediaDigests []string `json:"media_digests,omitempty"`
 }
 
 // TextMemoryAPI provides access to chronological text event storage.
@@ -40,27 +45,54 @@ type TextMemoryAPI interface {
 }
 
 // TextEvent represents a single text memory event.
+// MediaAttachment 描述一份与记忆关联的媒体。
+//
+// 两个方向共用一个类型：
+//   - 写入（InsertWithMedia）：给 Data + MIME 就是新内容；只给 Digest 则是引用已有内容。
+//   - 读出（Query）：内核只填 Digest/MIME，**不回 Data**——
+//     一次检索可能命中几十张图，把字节全塞回插件会把 ABI 消息撑爆。
+//     需要字节时拿 Digest 单独取。
+//
+// 刻意没有 Description 字段：媒体不作为文本被索引，也不带任何生成的描述。
+// 它只按自己的原生向量被检索与召回；附加文字请写在文档 / 三元组的文本里。
+type MediaAttachment struct {
+	Digest string `json:"digest,omitempty"`
+	MIME   string `json:"mime,omitempty"`
+	Data   []byte `json:"data,omitempty"`
+	Name   string `json:"name,omitempty"`
+}
+
 type TextEvent struct {
-	Role      string `json:"role"`
-	Content   string `json:"content"`
-	Timestamp int64  `json:"timestamp"`
-	Channel   string `json:"channel,omitempty"`
+	Role        string            `json:"role"`
+	Content     string            `json:"content"`
+	Timestamp   int64             `json:"timestamp"`
+	Channel     string            `json:"channel,omitempty"`
+	Attachments []MediaAttachment `json:"attachments,omitempty"`
 }
 
 // DocMemoryAPI provides access to the document vector store.
 type DocMemoryAPI interface {
 	Query(text string, topK int) []*Doc
 	Insert(doc *Doc) error
+	// InsertWithMedia 写入文档并关联媒体。attachments 里带 Data 的会落进
+	// 内容寻址存储（相同字节只存一份），只带 Digest 的直接引用已有内容。
+	// 媒体成为文档直接持有的一等记忆块：文档向量会融合它们的原生向量，
+	// 因此图片按自己的向量被召回，不依赖任何生成的描述文本。
+	InsertWithMedia(doc *Doc, attachments []MediaAttachment) error
 	Remove(id string)
 	Stats() map[string]interface{}
 }
 
 // Doc represents a document in the document store.
+//
+// MediaDigests / Attachments 在 Query 返回时由内核填充（仅元数据，不带字节）。
 type Doc struct {
-	ID      string  `json:"id"`
-	Title   string  `json:"title"`
-	Content string  `json:"content"`
-	Score   float64 `json:"score,omitempty"`
+	ID           string            `json:"id"`
+	Title        string            `json:"title"`
+	Content      string            `json:"content"`
+	Score        float64           `json:"score,omitempty"`
+	MediaDigests []string          `json:"media_digests,omitempty"`
+	Attachments  []MediaAttachment `json:"attachments,omitempty"`
 }
 
 // SocialAPI provides read-only access to the social graph (person profiles and relationships).
@@ -75,9 +107,9 @@ type SocialAPI interface {
 
 // PersonProfile represents a person's complete profile (traits + social relations).
 type PersonProfile struct {
-	Name      string              `json:"name"`
-	Traits    map[string]string   `json:"traits,omitempty"`
-	Relations []SocialRelation    `json:"relations,omitempty"`
+	Name      string            `json:"name"`
+	Traits    map[string]string `json:"traits,omitempty"`
+	Relations []SocialRelation  `json:"relations,omitempty"`
 }
 
 // SocialRelation represents a social relationship between two persons.

sdk/plugin.go

@@ -35,12 +35,63 @@ const (
 	StageAfterOutput    Stage = "after_output"
 )
 
+// 上下文策略：决定一次工具调用/输入/注入是否依据其内容裁剪上下文。
+//
+// 默认（空串或 ContextPolicyNone）**不裁剪**：裁剪会归档丢弃低相关事件，
+// 必须由工具/通道/注入点显式声明才发生——否则一个只想往上下文里塞内容的
+// 插件会在背后把别人的内容挤掉，且看不出是谁干的。
+const (
+	ContextPolicyNone  = "none"
+	ContextPolicyPrune = "prune"
+)
+
+// ValidContextPolicy 校验策略取值；空串等价于 ContextPolicyNone。
+func ValidContextPolicy(policy string) bool {
+	switch policy {
+	case "", ContextPolicyNone, ContextPolicyPrune:
+		return true
+	}
+	return false
+}
+
+// InjectOptions 声明一次注入行为在记忆层与上下文层的表现。
+//
+// 零值 = 记入记忆 + 不裁剪上下文，与历史行为（三参数注入方法）完全一致，
+// 因此调用方只有在确实需要改变行为时才需要填它。
+//
+// 为什么注入也要这两个标志：注入的内容来源千差万别——轮询到的频道消息
+// 属于真实对话（该记），而“任务还在跑”“连接已重连”这类提醒不该污染记忆，
+// 也不该把上下文按它的内容裁一遍。按调用点声明比按通道一刀切准确。
+//
+// NoMemory:       此次注入不参与记忆计算（向量化/关键词提取/蒸馏），原文仍留在上下文
+// ContextPolicy:  此次注入后是否依据（清洗后的）内容裁剪上下文；默认不裁剪。
+//
+//	中断注入也允许声明 prune——它同样会携带内容进入上下文。
+//
+// CleanerName:    此次注入的内容用哪个**已注册的通道 cleaner** 清洗。
+//
+//	空串 = 按注入的 source 查通道定义（既有行为）。
+//	为什么要能显式指定：注入的 source 未必是注册过的输入通道名，
+//	而注入内容往往带 ANSI/JSON 包装，需要清洗后才是有效内容；
+//	不指定就只能退到「按 source 查不到就不清洗」。
+type InjectOptions struct {
+	NoMemory      bool
+	ContextPolicy string
+	CleanerName   string
+}
+
 // ChannelDef 描述通道在记忆计算层的行为，与 ToolDef.NoMemory/Cleaner 语义一致。
 // NoMemory: 此通道输入/输出不参与记忆计算（向量化/关键词提取/蒸馏），但原文保留在上下文中
 // Cleaner:  计算层过滤函数，不改原文；仅在向量化/jieba/蒸馏/存档提取关键词时调用
+// ContextPolicy: 此通道的输入到达后是否据此裁剪上下文，默认 none（不裁剪）
+//
+// JSON tag 是必需的：通道定义要跨进程传给内核，而 Cleaner 是函数（必须忽略）。
+// 没有 tag 时既无法整体 marshal（func 不支持），又会诱使调用方手写字段白名单——
+// 那样新增字段会被静默丢掉。
 type ChannelDef struct {
-	NoMemory bool
-	Cleaner  func(string) string
+	NoMemory      bool                `json:"no_memory,omitempty"`
+	Cleaner       func(string) string `json:"-"`
+	ContextPolicy string              `json:"context_policy,omitempty"`
 }
 
 // StageContext provides context for stage handlers.
@@ -61,14 +112,18 @@ type StageContext struct {
 	Memory           []MemItem
 	NoMemory         bool
 	Extra            map[string]interface{}
-	Errors           []string               // 阶段处理过程中的错误信息
+	Errors           []string // 阶段处理过程中的错误信息
 }
 
-func (c *StageContext) RLock()                         { c.mu.RLock() }
-func (c *StageContext) RUnlock()                       { c.mu.RUnlock() }
-func (c *StageContext) Lock()                          { c.mu.Lock() }
-func (c *StageContext) Unlock()                        { c.mu.Unlock() }
-func (c *StageContext) IsResponded() bool               { c.mu.RLock(); defer c.mu.RUnlock(); return c.Response != nil }
+func (c *StageContext) RLock()   { c.mu.RLock() }
+func (c *StageContext) RUnlock() { c.mu.RUnlock() }
+func (c *StageContext) Lock()    { c.mu.Lock() }
+func (c *StageContext) Unlock()  { c.mu.Unlock() }
+func (c *StageContext) IsResponded() bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.Response != nil
+}
 
 // MemItem represents a memory item in stage context.
 type MemItem struct {
@@ -96,12 +151,13 @@ type ToolResult struct {
 
 // ToolDef describes a tool that the plugin exposes.
 type ToolDef struct {
-	Name        string                 `json:"name"`
-	Plugin      string                 `json:"plugin,omitempty"`
-	Description string                 `json:"description"`
-	Parameters  map[string]interface{} `json:"parameters"`
-	NoMemory    bool                   `json:"no_memory,omitempty"`  // 此工具输出不参与记忆计算，但原文保留
-	Cleaner     func(string) string    `json:"-"`                    // 计算层过滤函数，不改原文；仅在向量化/jieba/蒸馏时调用
+	Name          string                 `json:"name"`
+	Plugin        string                 `json:"plugin,omitempty"`
+	Description   string                 `json:"description"`
+	Parameters    map[string]interface{} `json:"parameters"`
+	NoMemory      bool                   `json:"no_memory,omitempty"`      // 此工具输出不参与记忆计算，但原文保留
+	Cleaner       func(string) string    `json:"-"`                        // 计算层过滤函数，不改原文；仅在向量化/jieba/蒸馏时调用
+	ContextPolicy string                 `json:"context_policy,omitempty"` // 上下文策略：""(默认，不裁剪) / ContextPolicyNone / ContextPolicyPrune
 }
 
 // IOInjector provides methods for injecting input and interrupts into the agent pipeline.
@@ -114,6 +170,23 @@ type IOInjector interface {
 	// InjectInputSync 注入输入事件并同步等待 agent 回复，返回回复文本（无回复时返回空串）。
 	// 用于通道消息的完整闭环：收到入站 → agent 处理 → 回复取回 → 送回通道。
 	InjectInputSync(source, channel, text string) string
+	// SetToolBlocks 插件工具注入多模态内容块（image_url/audio_url），内核在下一条
+	// tool message 的 content 数组里带上这些块，让模型在后续轮次看到图/听到音频。
+	SetToolBlocks(blocks []ContentBlock)
+	InjectInputMedia(source, channel, text string, blocks []ContentBlock)
+	InjectInputMediaSync(source, channel, text string, blocks []ContentBlock) string
+	InjectInterruptMedia(source, channel, text string, blocks []ContentBlock)
+
+	// 以下 Opts 变体让调用点在**这一次注入**上声明记忆与裁剪行为。
+	//
+	// 上面那些不带 opts 的方法等价于传零值 InjectOptions（记入记忆 + 不裁剪），
+	// 保留它们是为了不破坏已有插件；新代码应当用 Opts 变体把意图写清楚。
+	InjectTextOpts(source, channel, text string, opts InjectOptions)
+	InjectInterruptTextOpts(source, channel, text string, opts InjectOptions)
+	InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string
+	InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+	InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string
+	InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
 }
 
 // EventType identifies the kind of system event.
@@ -127,6 +200,11 @@ const (
 	EventReasoning     EventType = "reasoning"
 	EventStage         EventType = "stage"
 	EventSystem        EventType = "system"
+
+	// 流式增量事件（token 级）：核心 process() 流式化后每收到一个增量块发布。
+	// 客户端可选订做真逐 token 渲染；聚合事件仍照常发布，旧订阅者不受影响。
+	EventReasoningDelta EventType = "reasoning_delta"
+	EventContentDelta   EventType = "content_delta"
 )
 
 // Event represents a system event published by the kernel.
@@ -147,6 +225,17 @@ type EventSubscriber interface {
 	Subscribe(eventType EventType, handler EventHandler) func()
 }
 
+// PluginMgrAPI 提供插件管理能力（外部插件可调用）。
+// 由 bridge 注入 dispatch 实现，走 C ABI CORE_PLUGIN_RELOAD_ONE 等。
+type PluginMgrAPI interface {
+	// ReloadOne 重载单个插件（停止后重新加载）。
+	ReloadOne(name string) error
+	// ListLoadedPlugins 列出已加载插件。
+	ListLoadedPlugins() []string
+	// IsPluginDisabled 查询插件是否被禁用。
+	IsPluginDisabled(name string) bool
+}
+
 // StageScope controls which events a stage handler receives.
 type StageScope int
 
@@ -200,6 +289,25 @@ type PluginSDK struct {
 	sett      SettingsAPI
 	social    SocialAPI
 	events    EventSubscriber
+	plgMgr    PluginMgrAPI
+
+	// apiMu 保护上面这些由内核注入的 API 字段，以及 autoRestart。
+	//
+	// 这些字段的写方与读方天然跨 goroutine：
+	//   - 写方是内核（加载/重载插件时注入 API）与插件自己（SetAutoRestart）；
+	//   - 读方是插件在 Start() 里起的后台 goroutine（轮询、监听、定时器
+	//     都要拿 injector 往管道里注消息），以及内核 registry —— 它在
+	//     另一个 goroutine 读 AutoRestart() 决定崩溃后是否重启。
+	// SetAutoRestart 的文档用法本身就是「连接建立后再决定能否自动重启」，
+	// 而连接建立通常发生在后台 goroutine 里，于是这对读写必然并发。
+	//
+	// sdk/stress_test.go 的 -race 实测确认这是真竞态，不是理论风险。
+	// 未加锁时的生产表现是偶发 nil 解引用崩溃（读到半个接口值）。
+	//
+	// 约定：只在持锁期间取字段值，取完立刻释放再调用。
+	// 持锁调用会把 InjectInputSync 这类阻塞到 agent 回复（可达数分钟）的
+	// 方法与 SetIOInjector 串到一起，让插件重载卡死。
+	apiMu sync.RWMutex
 
 	autoRestart bool
 
@@ -227,28 +335,57 @@ func New(name string, sett SettingsAPI, regTool ToolRegistrar, regStage StageReg
 func (s *PluginSDK) PluginName() string { return s.name }
 
 // Settings returns the settings API for reading/writing plugin configuration.
+// sett 在 New 时一次性写入且无 setter，故不需要加锁。
 func (s *PluginSDK) Settings() SettingsAPI { return s.sett }
 
 // Memory returns the graph memory API (may be nil if not available).
-func (s *PluginSDK) Memory() MemoryAPI { return s.mem }
+func (s *PluginSDK) Memory() MemoryAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.mem
+}
 
 // TextMemory returns the text memory API (may be nil if not available).
-func (s *PluginSDK) TextMemory() TextMemoryAPI { return s.textMem }
+func (s *PluginSDK) TextMemory() TextMemoryAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.textMem
+}
 
 // DocMemory returns the document memory API (may be nil if not available).
-func (s *PluginSDK) DocMemory() DocMemoryAPI { return s.docMem }
+func (s *PluginSDK) DocMemory() DocMemoryAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.docMem
+}
 
 // Knowledge returns the knowledge store API (may be nil if not available).
-func (s *PluginSDK) Knowledge() KnowledgeAPI { return s.know }
+func (s *PluginSDK) Knowledge() KnowledgeAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.know
+}
 
 // LLM returns the LLM provider API (may be nil if not available).
-func (s *PluginSDK) LLM() LLMAPI { return s.llm }
+func (s *PluginSDK) LLM() LLMAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.llm
+}
 
 // Social returns the social graph API (may be nil if not available).
-func (s *PluginSDK) Social() SocialAPI { return s.social }
+func (s *PluginSDK) Social() SocialAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.social
+}
 
 // Events returns the event subscriber for listening to kernel events (may be nil if not available).
-func (s *PluginSDK) Events() EventSubscriber { return s.events }
+func (s *PluginSDK) Events() EventSubscriber {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.events
+}
 
 // RegisterTool registers a tool that the LLM can call.
 func (s *PluginSDK) RegisterTool(name string, def ToolDef, handler ToolHandler) error {
@@ -262,8 +399,9 @@ func (s *PluginSDK) RegisterTool(name string, def ToolDef, handler ToolHandler)
 }
 
 // RegisterStage registers a handler for a pipeline stage.
-//   scope: StageScopeGlobal (default) — receives all stage events.
-//          StageScopeOwnTools — only before_toolcall/after_toolcall for this plugin's tools.
+//
+//	scope: StageScopeGlobal (default) — receives all stage events.
+//	       StageScopeOwnTools — only before_toolcall/after_toolcall for this plugin's tools.
 func (s *PluginSDK) RegisterStage(stage Stage, handler StageHandler, scope ...StageScope) {
 	if s.regStage == nil {
 		return
@@ -313,8 +451,11 @@ func (s *PluginSDK) RegisterPluginAPI(name string) error {
 // def:  通道在记忆计算层的行为（NoMemory/Cleaner）
 // handler: receives args map with keys: payload (string), type (string), meta (string|optional)
 func (s *PluginSDK) RegisterOutputChannel(name string, caps int, desc string, def ChannelDef, handler ToolHandler) error {
-	if s.regOutput != nil {
-		return s.regOutput(name, caps, desc, def, handler)
+	s.apiMu.RLock()
+	reg := s.regOutput
+	s.apiMu.RUnlock()
+	if reg != nil {
+		return reg(name, caps, desc, def, handler)
 	}
 	return nil
 }
@@ -323,69 +464,229 @@ func (s *PluginSDK) RegisterOutputChannel(name string, caps int, desc string, de
 // def.NoMemory: 此通道输入不参与记忆计算
 // def.Cleaner:  计算层对输入文本清洗后（不改原文）再向量化/提关键词
 func (s *PluginSDK) RegisterInputChannel(name string, def ChannelDef) error {
-	if s.regInput != nil {
-		return s.regInput(name, def)
+	s.apiMu.RLock()
+	reg := s.regInput
+	s.apiMu.RUnlock()
+	if reg != nil {
+		return reg(name, def)
 	}
 	return nil
 }
 
+// 以下 setter 由内核在启动/重载时调用，与插件后台 goroutine 的读并发，故加锁。
+
 // SetOutputChannelRegistrar sets the output channel registrar (called by the core at startup).
-func (s *PluginSDK) SetOutputChannelRegistrar(r OutputChannelRegistrar) { s.regOutput = r }
+func (s *PluginSDK) SetOutputChannelRegistrar(r OutputChannelRegistrar) {
+	s.apiMu.Lock()
+	s.regOutput = r
+	s.apiMu.Unlock()
+}
 
 // SetInputChannelRegistrar sets the input channel registrar (called by the core at startup).
-func (s *PluginSDK) SetInputChannelRegistrar(r InputChannelRegistrar) { s.regInput = r }
+func (s *PluginSDK) SetInputChannelRegistrar(r InputChannelRegistrar) {
+	s.apiMu.Lock()
+	s.regInput = r
+	s.apiMu.Unlock()
+}
 
 // SetIOInjector sets the IO injector (called by the core at startup).
-func (s *PluginSDK) SetIOInjector(io IOInjector) { s.io = io }
+func (s *PluginSDK) SetIOInjector(io IOInjector) {
+	s.apiMu.Lock()
+	s.io = io
+	s.apiMu.Unlock()
+}
 
 // SetMemoryAPI sets the memory API (called by the core at startup).
-func (s *PluginSDK) SetMemoryAPI(mem MemoryAPI)       { s.mem = mem }
-func (s *PluginSDK) SetTextMemoryAPI(tm TextMemoryAPI) { s.textMem = tm }
-func (s *PluginSDK) SetDocMemoryAPI(dm DocMemoryAPI)   { s.docMem = dm }
-func (s *PluginSDK) SetKnowledgeAPI(kn KnowledgeAPI)   { s.know = kn }
-func (s *PluginSDK) SetLLMAPI(llm LLMAPI)              { s.llm = llm }
-func (s *PluginSDK) SetSocialAPI(social SocialAPI)      { s.social = social }
-func (s *PluginSDK) SetEventSubscriber(es EventSubscriber) { s.events = es }
+func (s *PluginSDK) SetMemoryAPI(mem MemoryAPI) {
+	s.apiMu.Lock()
+	s.mem = mem
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetTextMemoryAPI(tm TextMemoryAPI) {
+	s.apiMu.Lock()
+	s.textMem = tm
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetDocMemoryAPI(dm DocMemoryAPI) {
+	s.apiMu.Lock()
+	s.docMem = dm
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetKnowledgeAPI(kn KnowledgeAPI) {
+	s.apiMu.Lock()
+	s.know = kn
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetLLMAPI(llm LLMAPI) {
+	s.apiMu.Lock()
+	s.llm = llm
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetSocialAPI(social SocialAPI) {
+	s.apiMu.Lock()
+	s.social = social
+	s.apiMu.Unlock()
+}
+
+func (s *PluginSDK) SetEventSubscriber(es EventSubscriber) {
+	s.apiMu.Lock()
+	s.events = es
+	s.apiMu.Unlock()
+}
+
+// SetPluginMgrAPI sets the plugin manager API (called by the bridge at startup).
+func (s *PluginSDK) SetPluginMgrAPI(pm PluginMgrAPI) {
+	s.apiMu.Lock()
+	s.plgMgr = pm
+	s.apiMu.Unlock()
+}
+
+// PluginMgr returns the plugin manager API (ReloadOne / ReloadPlugins / list).
+// May be nil if the host did not wire it.
+func (s *PluginSDK) PluginMgr() PluginMgrAPI {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.plgMgr
+}
 
 // ---- IO Convenience Methods ----
 
+// injector 取当前 injector 的快照。
+//
+// 取完即释放锁再调用：InjectInputSync 会阻塞到 agent 回复（可达数分钟），
+// 若持锁调用，插件重载时的 SetIOInjector 会一起卡住。
+func (s *PluginSDK) injector() IOInjector {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.io
+}
+
 // InjectInterruptText injects a text interrupt that can preempt current LLM processing.
+// 等价于 InjectInterruptTextOpts(..., InjectOptions{})：记入记忆、不裁剪。
 func (s *PluginSDK) InjectInterruptText(source, channel, text string) {
-	if s.io != nil {
-		s.io.InjectInterruptText(source, channel, text)
-	}
+	s.InjectInterruptTextOpts(source, channel, text, InjectOptions{})
 }
 
 // InjectText injects a text message into the agent pipeline.
+// 等价于 InjectTextOpts(..., InjectOptions{})：记入记忆、不裁剪。
 func (s *PluginSDK) InjectText(source, channel, text string) {
-	if s.io != nil {
-		s.io.InjectText(source, channel, text)
-	}
+	s.InjectTextOpts(source, channel, text, InjectOptions{})
 }
 
 // InjectTextNoMemory injects a text message without generating memory.
+// 等价于 InjectTextOpts(..., InjectOptions{NoMemory: true})。
 func (s *PluginSDK) InjectTextNoMemory(source, channel, text string) {
-	if s.io != nil {
-		s.io.InjectTextNoMemory(source, channel, text)
-	}
+	s.InjectTextOpts(source, channel, text, InjectOptions{NoMemory: true})
 }
 
 // InjectInputSync injects a text message and synchronously waits for the agent reply,
 // returning the reply text (empty string if none). Replies must be dispatched back
 // to the source channel by the caller.
 func (s *PluginSDK) InjectInputSync(source, channel, text string) string {
-	if s.io == nil {
+	return s.InjectInputSyncOpts(source, channel, text, InjectOptions{})
+}
+
+// InjectInputMedia 注入带媒体内容块（image_url/audio_url）的输入。
+// blocks 会落进媒体存储被记忆引用捕获，同时作为当前轮 content 数组
+// 发给 LLM，让模型在「本轮」就看到图/听到音频——区别于 SetToolBlocks
+// 的「下一轮 tool message」语义。
+// 等价于 InjectInputMediaOpts(..., InjectOptions{})。
+func (s *PluginSDK) InjectInputMedia(source, channel, text string, blocks []ContentBlock) {
+	s.InjectInputMediaOpts(source, channel, text, blocks, InjectOptions{})
+}
+
+// InjectInputMediaSync 注入带媒体内容块的输入并同步等待 agent 回复。
+// 等价于 InjectInputMediaSyncOpts(..., InjectOptions{})。
+func (s *PluginSDK) InjectInputMediaSync(source, channel, text string, blocks []ContentBlock) string {
+	return s.InjectInputMediaSyncOpts(source, channel, text, blocks, InjectOptions{})
+}
+
+// ---- 带 InjectOptions 的注入（声明记忆/裁剪行为）----
+
+// InjectTextOpts 注入文本到 agent，并在这一次注入上声明记忆与裁剪行为。
+func (s *PluginSDK) InjectTextOpts(source, channel, text string, opts InjectOptions) {
+	if io := s.injector(); io != nil {
+		io.InjectTextOpts(source, channel, text, opts)
+	}
+}
+
+// InjectInterruptTextOpts 注入可抢占当前处理的中断文本。
+//
+// 中断也允许声明 ContextPolicyPrune：中断同样携带内容进入上下文，
+// 是否需要据此裁剪由调用方决定（默认不裁剪）。
+func (s *PluginSDK) InjectInterruptTextOpts(source, channel, text string, opts InjectOptions) {
+	if io := s.injector(); io != nil {
+		io.InjectInterruptTextOpts(source, channel, text, opts)
+	}
+}
+
+// InjectInputSyncOpts 注入输入并同步等待回复，同时在这次注入上声明记忆/裁剪行为。
+func (s *PluginSDK) InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string {
+	io := s.injector()
+	if io == nil {
 		return ""
 	}
-	return s.io.InjectInputSync(source, channel, text)
+	return io.InjectInputSyncOpts(source, channel, text, opts)
+}
+
+// InjectInputMediaOpts 注入带媒体块的输入，并声明记忆/裁剪行为。
+func (s *PluginSDK) InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) {
+	if io := s.injector(); io != nil {
+		io.InjectInputMediaOpts(source, channel, text, blocks, opts)
+	}
+}
+
+// InjectInputMediaSyncOpts 注入带媒体块的输入并同步等待回复，同时声明记忆/裁剪行为。
+func (s *PluginSDK) InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string {
+	io := s.injector()
+	if io == nil {
+		return ""
+	}
+	return io.InjectInputMediaSyncOpts(source, channel, text, blocks, opts)
+}
+
+// InjectInterruptMediaOpts 注入带媒体块的中断，并声明记忆/裁剪行为。
+func (s *PluginSDK) InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) {
+	if io := s.injector(); io != nil {
+		io.InjectInterruptMediaOpts(source, channel, text, blocks, opts)
+	}
+}
+
+// InjectInterruptMedia 注入带媒体内容块的中断，可抢占当前 LLM 处理。
+// blocks 随中断消息一起发给模型。
+func (s *PluginSDK) InjectInterruptMedia(source, channel, text string, blocks []ContentBlock) {
+	if io := s.injector(); io != nil {
+		io.InjectInterruptMedia(source, channel, text, blocks)
+	}
+}
+
+// SetToolBlocks 在工具处理函数内注入多模态内容块，内核在下一条 tool message
+// 的 content 数组里带上它们。需要「本轮就让模型看到」时用 InjectInputMedia。
+func (s *PluginSDK) SetToolBlocks(blocks []ContentBlock) {
+	if io := s.injector(); io != nil {
+		io.SetToolBlocks(blocks)
+	}
 }
 
 // SetAutoRestart 设置插件是否允许内核自动重启（崩溃后自动重载）。
 // 默认 true。如果插件有无法恢复的状态（如外部连接），应设为 false。
-func (s *PluginSDK) SetAutoRestart(enabled bool) { s.autoRestart = enabled }
+func (s *PluginSDK) SetAutoRestart(enabled bool) {
+	s.apiMu.Lock()
+	s.autoRestart = enabled
+	s.apiMu.Unlock()
+}
 
 // AutoRestart 返回插件是否允许自动重启。
-func (s *PluginSDK) AutoRestart() bool { return s.autoRestart }
+func (s *PluginSDK) AutoRestart() bool {
+	s.apiMu.RLock()
+	defer s.apiMu.RUnlock()
+	return s.autoRestart
+}
 
 // RegisterStopHandler 注册插件停止阶段的清理回调。
 // 注册的 handler 会在插件 Stop() 之前按"后注册先执行"的顺序调用，
@@ -436,3 +737,22 @@ func (s *PluginSDK) RunOnRemoveHandlers() {
 		handlers[i]()
 	}
 }
+
+// ContentBlock 是多模态内容块（OpenAI 格式：text/image_url/audio_url）。
+// 插件工具返回结果时可用 PluginSDK.SetToolBlocks 注入，让下一轮 LLM
+// 请求在 tool message 的 content 数组里带上图片/音频，实现"模型看图/听音频"。
+type ContentBlock struct {
+	Type     string    `json:"type"`
+	Text     string    `json:"text,omitempty"`
+	ImageURL *ImageURL `json:"image_url,omitempty"`
+	AudioURL *AudioURL `json:"audio_url,omitempty"`
+}
+
+type ImageURL struct {
+	URL    string `json:"url"`
+	Detail string `json:"detail,omitempty"`
+}
+
+type AudioURL struct {
+	URL string `json:"url"`
+}

sdk/settings.go

@@ -19,6 +19,11 @@ type SettingsAPI interface {
 	// ListCore lists core config keys matching the prefix.
 	ListCore(prefix string) ([]string, error)
 
+	// DataDir returns the plugin-specific data directory (guaranteed to exist):
+	// <daemon data>/plugin_data/<plugin_name>. Plugins should persist any
+	// runtime files (generated images, caches, downloads) here.
+	DataDir() string
+
 	// GetPlugin reads another plugin's config table.
 	GetPlugin(plugin, key string) (interface{}, error)
 

sdk/stress_test.go

@@ -0,0 +1,760 @@
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+)
+
+// SDK 公开接口的并发压力测试（1.1.0 媒体接口上线后新增）。
+//
+// 为什么这一层需要压测：SDK 是**被多个 goroutine 同时使用的共享对象**。
+// 一个插件的典型形态是 Start() 里起若干后台 goroutine（轮询、监听、定时器），
+// 它们各自持同一个 *PluginSDK 往里注入消息；内核侧同时还有 stage 扇出、
+// 工具调用、以及读 AutoRestart() 决定崩溃后是否重启。
+// 单线程单测全绿不代表这些并发路径成立。
+//
+// 关注点不是吞吐数字，而是不变量：
+//   1. 注入调用不丢、不串（媒体块必须与文本配对，不能张冠李戴）
+//   2. 状态字段的读写不产生数据竞争（-race 下必须干净）
+//   3. handler 注册/执行在并发下"恰好一次"
+//   4. 跨进程 JSON 序列化对新媒体类型必须字节级往返一致
+//
+// 媒体接口尤其需要 3 与 4：媒体块要经 JSON 过子进程边界，
+// 而 []byte 在 JSON 里是 base64，往返不一致的后果是图片静默损坏。
+
+// ---------- 测试替身 ----------
+
+// recordingInjector 记录每一次注入调用，用于验证"不丢不串"。
+type recordingInjector struct {
+	mu    sync.Mutex
+	calls []injectCall
+
+	// 计数用原子量：并发路径上只增不减，可在不持锁时安全读。
+	nText, nMedia, nInterrupt, nSync atomic.Int64
+}
+
+type injectCall struct {
+	kind    string // text / media / interruptMedia / sync ...
+	source  string
+	channel string
+	text    string
+	blocks  []ContentBlock
+	opts    InjectOptions // 调用点声明的记忆/裁剪行为
+}
+
+func (r *recordingInjector) record(c injectCall) {
+	r.mu.Lock()
+	r.calls = append(r.calls, c)
+	r.mu.Unlock()
+}
+
+func (r *recordingInjector) InjectInterruptText(s, c, t string) {
+	r.nInterrupt.Add(1)
+	r.record(injectCall{kind: "interruptText", source: s, channel: c, text: t})
+}
+
+func (r *recordingInjector) InjectText(s, c, t string) {
+	r.nText.Add(1)
+	r.record(injectCall{kind: "text", source: s, channel: c, text: t})
+}
+
+func (r *recordingInjector) InjectTextNoMemory(s, c, t string) {
+	r.nText.Add(1)
+	r.record(injectCall{kind: "textNoMem", source: s, channel: c, text: t})
+}
+
+func (r *recordingInjector) InjectInputSync(s, c, t string) string {
+	r.nSync.Add(1)
+	r.record(injectCall{kind: "sync", source: s, channel: c, text: t})
+	return "reply:" + t
+}
+
+func (r *recordingInjector) SetToolBlocks(blocks []ContentBlock) {
+	r.record(injectCall{kind: "toolBlocks", blocks: blocks})
+}
+
+func (r *recordingInjector) InjectInputMedia(s, c, t string, b []ContentBlock) {
+	r.nMedia.Add(1)
+	r.record(injectCall{kind: "media", source: s, channel: c, text: t, blocks: b})
+}
+
+func (r *recordingInjector) InjectInputMediaSync(s, c, t string, b []ContentBlock) string {
+	r.nMedia.Add(1)
+	r.nSync.Add(1)
+	r.record(injectCall{kind: "mediaSync", source: s, channel: c, text: t, blocks: b})
+	return "reply:" + t
+}
+
+func (r *recordingInjector) InjectInterruptMedia(s, c, t string, b []ContentBlock) {
+	r.nMedia.Add(1)
+	r.record(injectCall{kind: "interruptMedia", source: s, channel: c, text: t, blocks: b})
+}
+
+// ---- 带 InjectOptions 的注入：记录 opts 以便测试断言标志位确实传到了内核 ----
+
+func (r *recordingInjector) InjectTextOpts(s, c, t string, o InjectOptions) {
+	r.nText.Add(1)
+	r.record(injectCall{kind: "textOpts", source: s, channel: c, text: t, opts: o})
+}
+
+func (r *recordingInjector) InjectInterruptTextOpts(s, c, t string, o InjectOptions) {
+	r.nInterrupt.Add(1)
+	r.record(injectCall{kind: "interruptTextOpts", source: s, channel: c, text: t, opts: o})
+}
+
+func (r *recordingInjector) InjectInputSyncOpts(s, c, t string, o InjectOptions) string {
+	r.nSync.Add(1)
+	r.record(injectCall{kind: "syncOpts", source: s, channel: c, text: t, opts: o})
+	return "reply:" + t
+}
+
+func (r *recordingInjector) InjectInputMediaOpts(s, c, t string, b []ContentBlock, o InjectOptions) {
+	r.nMedia.Add(1)
+	r.record(injectCall{kind: "mediaOpts", source: s, channel: c, text: t, blocks: b, opts: o})
+}
+
+func (r *recordingInjector) InjectInputMediaSyncOpts(s, c, t string, b []ContentBlock, o InjectOptions) string {
+	r.nMedia.Add(1)
+	r.nSync.Add(1)
+	r.record(injectCall{kind: "mediaSyncOpts", source: s, channel: c, text: t, blocks: b, opts: o})
+	return "reply:" + t
+}
+
+func (r *recordingInjector) InjectInterruptMediaOpts(s, c, t string, b []ContentBlock, o InjectOptions) {
+	r.nMedia.Add(1)
+	r.record(injectCall{kind: "interruptMediaOpts", source: s, channel: c, text: t, blocks: b, opts: o})
+}
+
+func (r *recordingInjector) snapshot() []injectCall {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return append([]injectCall{}, r.calls...)
+}
+
+var _ IOInjector = (*recordingInjector)(nil)
+
+// imageBlock 构造一个带可识别 URL 的图片块。
+func imageBlock(tag string) ContentBlock {
+	return ContentBlock{
+		Type:     "image_url",
+		ImageURL: &ImageURL{URL: "data:image/png;base64," + tag, Detail: "auto"},
+	}
+}
+
+// ---------- 1. 媒体注入并发不丢不串 ----------
+
+// 三个媒体注入方法在高并发下必须：调用数精确、且每次调用的 text 与 blocks 配对不错。
+//
+// "不串"是这里的关键断言。注入是插件里最容易被后台 goroutine 并发调用的入口，
+// 若实现里出现任何共享中间状态（比如把 blocks 暂存到 SDK 字段再读出），
+// 高并发下就会出现 A 的文本配上 B 的图——而两者单独看都"成功"了，不报错。
+func TestStress_MediaInjectionConcurrentNoCrossTalk(t *testing.T) {
+	const workers, perWorker = 32, 200
+
+	inj := &recordingInjector{}
+	s := &PluginSDK{name: "stress"}
+	s.SetIOInjector(inj)
+
+	var wg sync.WaitGroup
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < perWorker; i++ {
+				// tag 唯一标识这次调用，文本与图片 URL 里都带上它。
+				tag := fmt.Sprintf("w%d-i%d", w, i)
+				switch i % 3 {
+				case 0:
+					s.InjectInputMedia("src", "ch", tag, []ContentBlock{imageBlock(tag)})
+				case 1:
+					if got := s.InjectInputMediaSync("src", "ch", tag, []ContentBlock{imageBlock(tag)}); got != "reply:"+tag {
+						t.Errorf("同步注入回复错位: got %q want %q", got, "reply:"+tag)
+					}
+				default:
+					s.InjectInterruptMedia("src", "ch", tag, []ContentBlock{imageBlock(tag)})
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+
+	total := int64(workers * perWorker)
+	if got := inj.nMedia.Load(); got != total {
+		t.Fatalf("媒体注入调用数 = %d，期望 %d（有调用丢失）", got, total)
+	}
+
+	// 逐条校验文本与媒体块配对：URL 必须含该次调用自己的 tag。
+	seen := map[string]bool{}
+	for _, c := range inj.snapshot() {
+		if len(c.blocks) == 0 {
+			continue
+		}
+		if c.blocks[0].ImageURL == nil {
+			t.Fatalf("媒体块 ImageURL 丢失: %+v", c.blocks[0])
+		}
+		if !strings.HasSuffix(c.blocks[0].ImageURL.URL, c.text) {
+			t.Fatalf("文本与媒体块错位: text=%q url=%q", c.text, c.blocks[0].ImageURL.URL)
+		}
+		if seen[c.text] {
+			t.Fatalf("同一次调用被记录两次: %s", c.text)
+		}
+		seen[c.text] = true
+	}
+	if len(seen) != int(total) {
+		t.Fatalf("去重后调用数 = %d，期望 %d", len(seen), total)
+	}
+}
+
+// ---------- 2. 注入期间热替换 injector ----------
+
+// 内核在插件运行期间可能重新注入 API（重载、恢复、子进程重连握手）。
+// 此时插件的后台 goroutine 仍在注入。这条路径若无同步就是对 s.io 的数据竞争，
+// 在 -race 下会被抓出；生产表现是偶发 nil 解引用崩溃。
+func TestStress_InjectorSwapDuringInjection(t *testing.T) {
+	s := &PluginSDK{name: "stress"}
+	s.SetIOInjector(&recordingInjector{})
+
+	stop := make(chan struct{})
+	var injectors, swapper sync.WaitGroup
+
+	// 注入方：持续打直到 stop
+	for w := 0; w < 8; w++ {
+		injectors.Add(1)
+		go func() {
+			defer injectors.Done()
+			for {
+				select {
+				case <-stop:
+					return
+				default:
+					s.InjectInputMedia("src", "ch", "x", []ContentBlock{imageBlock("x")})
+					s.InjectText("src", "ch", "y")
+				}
+			}
+		}()
+	}
+
+	// 替换方：反复换 injector（含换成 nil——内核卸载 API 时的真实状态）
+	swapper.Add(1)
+	go func() {
+		defer swapper.Done()
+		for i := 0; i < 500; i++ {
+			if i%7 == 0 {
+				s.SetIOInjector(nil)
+			} else {
+				s.SetIOInjector(&recordingInjector{})
+			}
+		}
+	}()
+
+	// 先等替换跑完，再告知注入方退出。
+	// 顺序写反了就是死锁：注入方只依 close(stop) 退出。
+	swapper.Wait()
+	close(stop)
+	injectors.Wait()
+	// 断言就是「没崩、-race 没报」。nil injector 时必须静默跳过而非 panic。
+}
+
+// ---------- 3. autoRestart 标志的并发读写 ----------
+
+// SetAutoRestart 的文档用途是"插件有无法恢复的状态（如外部连接）时设为 false"——
+// 而连接建立本身通常是异步的，所以这个写入天然发生在后台 goroutine。
+// 内核侧 registry 在另一个 goroutine 读 AutoRestart() 决定崩溃后是否重启。
+// 这是一对跨 goroutine 的读写，必须同步。
+func TestStress_AutoRestartFlagConcurrent(t *testing.T) {
+	s := &PluginSDK{name: "stress", autoRestart: true}
+
+	var wg sync.WaitGroup
+	for w := 0; w < 16; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < 500; i++ {
+				s.SetAutoRestart(i%2 == 0)
+			}
+		}(w)
+	}
+	// 读方模拟内核 registry
+	for r := 0; r < 8; r++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for i := 0; i < 500; i++ {
+				_ = s.AutoRestart()
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+// ---------- 4. stop / onRemove handler 的"恰好一次" ----------
+
+// RunStopHandlers 的契约是"执行后清空，幂等"。内核在停止插件时可能并发触发
+// （超时强杀与正常 Stop 竞争），handler 里往往是关连接、落盘——
+// 执行两次的后果从"重复写文件"到"close 已关闭的 channel 直接 panic"。
+func TestStress_StopHandlersExactlyOnce(t *testing.T) {
+	const n = 300
+	s := &PluginSDK{name: "stress"}
+
+	var counters [n]atomic.Int64
+	for i := 0; i < n; i++ {
+		i := i
+		s.RegisterStopHandler(func() { counters[i].Add(1) })
+	}
+
+	var wg sync.WaitGroup
+	for w := 0; w < 16; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			s.RunStopHandlers()
+		}()
+	}
+	wg.Wait()
+
+	for i := 0; i < n; i++ {
+		if got := counters[i].Load(); got != 1 {
+			t.Fatalf("handler %d 执行 %d 次，期望恰好 1 次", i, got)
+		}
+	}
+}
+
+// 注册与执行并发：已注册的 handler 一次都不能多跑，未跑到的也不能被丢。
+// 断言用"每个 handler 的执行次数 <= 1"而非"总数相等"——
+// 与 RunStopHandlers 竞争的注册可能落在快照之后，那属于合法的未执行。
+func TestStress_StopHandlersRegisterWhileRunning(t *testing.T) {
+	s := &PluginSDK{name: "stress"}
+	const n = 500
+	var counters [n]atomic.Int64
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for i := 0; i < n; i++ {
+			i := i
+			s.RegisterStopHandler(func() { counters[i].Add(1) })
+		}
+	}()
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 50; i++ {
+			s.RunStopHandlers()
+		}
+	}()
+	wg.Wait()
+	s.RunStopHandlers() // 收尾：把剩下的都跑掉
+
+	for i := 0; i < n; i++ {
+		if got := counters[i].Load(); got > 1 {
+			t.Fatalf("handler %d 被执行 %d 次（重复执行）", i, got)
+		}
+	}
+}
+
+func TestStress_OnRemoveHandlersExactlyOnce(t *testing.T) {
+	const n = 200
+	s := &PluginSDK{name: "stress"}
+
+	var counters [n]atomic.Int64
+	for i := 0; i < n; i++ {
+		i := i
+		s.RegisterOnRemoveHandler(func() { counters[i].Add(1) })
+	}
+
+	var wg sync.WaitGroup
+	for w := 0; w < 12; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			s.RunOnRemoveHandlers()
+		}()
+	}
+	wg.Wait()
+
+	for i := 0; i < n; i++ {
+		if got := counters[i].Load(); got != 1 {
+			t.Fatalf("onRemove handler %d 执行 %d 次，期望恰好 1 次", i, got)
+		}
+	}
+}
+
+// ---------- 5. StageContext 并发读改写 ----------
+
+// StageContext 是全部 stage handler 共享的可变状态，字段全导出、靠调用方自觉
+// 持 Lock/RLock。媒体链路让 Extra 成为新热点（media_blocks 挂在这里），
+// 而 map 的并发写在 Go 里是直接 fatal，recover 都接不住。
+//
+// 这条测试锁定的不变量：按约定持锁的并发读改写不丢更新、不 fatal。
+func TestStress_StageContextConcurrentExtraAndFinalText(t *testing.T) {
+	ctx := &StageContext{Extra: map[string]interface{}{}}
+
+	const workers, rounds = 16, 200
+	var wg sync.WaitGroup
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < rounds; i++ {
+				// 写：模拟插件往 Extra 塞媒体块并追加文本（读-改-写）
+				ctx.Lock()
+				ctx.Extra[fmt.Sprintf("k%d-%d", w, i)] = []ContentBlock{imageBlock("x")}
+				ctx.FinalText += "."
+				ctx.Unlock()
+
+				// 读：模拟另一个 handler 检查是否已被响应
+				_ = ctx.IsResponded()
+				ctx.RLock()
+				_ = len(ctx.Extra)
+				ctx.RUnlock()
+			}
+		}(w)
+	}
+	wg.Wait()
+
+	ctx.RLock()
+	defer ctx.RUnlock()
+	if len(ctx.Extra) != workers*rounds {
+		t.Fatalf("Extra 键数 = %d，期望 %d（出现 lost update）", len(ctx.Extra), workers*rounds)
+	}
+	if len(ctx.FinalText) != workers*rounds {
+		t.Fatalf("FinalText 长度 = %d，期望 %d（出现 lost update）", len(ctx.FinalText), workers*rounds)
+	}
+}
+
+// ---------- 6. OwnTools scope 包装器的并发正确性 ----------
+
+// StageScopeOwnTools 的包装闭环里要读 ctx.ToolCalls 判断归属。
+// 并发下若判断与执行之间状态被改写，就会出现"别人的工具触发了我的 handler"——
+// 后果是插件对不属于自己的工具结果动手，且没有任何错误。
+func TestStress_OwnToolsScopeNoCrossPluginLeak(t *testing.T) {
+	var registered StageHandler
+	s := &PluginSDK{
+		name:     "mine",
+		regStage: func(stage Stage, h StageHandler) { registered = h },
+	}
+
+	var fired atomic.Int64
+	s.RegisterStage(StageBeforeToolcall, func(ctx *StageContext) error {
+		fired.Add(1)
+		ctx.RLock()
+		defer ctx.RUnlock()
+		// 触发了就必须确实是自己的工具
+		if len(ctx.ToolCalls) == 0 || ctx.ToolCalls[0].Plugin != "mine" {
+			t.Errorf("handler 被别的插件的工具触发: %+v", ctx.ToolCalls)
+		}
+		return nil
+	}, StageScopeOwnTools)
+
+	if registered == nil {
+		t.Fatal("handler 未注册")
+	}
+
+	const workers, rounds = 16, 100
+	var wg sync.WaitGroup
+	var mineCount atomic.Int64
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < rounds; i++ {
+				// 每个 goroutine 用自己的 ctx——真实内核里 stage 扇出共享同一个
+				// ctx，但那部分的并发由内核 host 仲裁；这里验证包装器本身。
+				owner := "other"
+				if (w+i)%2 == 0 {
+					owner = "mine"
+					mineCount.Add(1)
+				}
+				ctx := &StageContext{Extra: map[string]interface{}{}}
+				ctx.ToolCalls = []ToolCall{{Plugin: owner, Name: "t"}}
+				if err := registered(ctx); err != nil {
+					t.Errorf("handler 返回错误: %v", err)
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+
+	if got, want := fired.Load(), mineCount.Load(); got != want {
+		t.Fatalf("handler 触发 %d 次，期望 %d 次（漏触发或跨插件触发）", got, want)
+	}
+}
+
+// ---------- 7. 媒体类型的 JSON 往返（跨进程边界的真实形态） ----------
+
+// 媒体块与附件要经 JSON 过子进程边界。[]byte 在 JSON 里是 base64，
+// 往返不一致的后果是图片字节静默损坏——落进 CAS 后 digest 校验才会发现，
+// 而那时已经无从追查是谁改坏的。
+func TestStress_MediaTypesJSONRoundTripAtScale(t *testing.T) {
+	// 覆盖真实会遇到的边界：空、单字节、含 0x00、全 0xFF、超过 base64 分组边界的长度
+	sizes := []int{0, 1, 2, 3, 255, 256, 1023, 4096, 65537}
+	for _, n := range sizes {
+		data := make([]byte, n)
+		for i := range data {
+			data[i] = byte(i * 7 % 256)
+		}
+		att := MediaAttachment{
+			Digest: strings.Repeat("a", 64),
+			MIME:   "image/png",
+			Data:   data,
+			Name:   "图片-名字 with space & 符号.png",
+		}
+		b, err := json.Marshal(att)
+		if err != nil {
+			t.Fatalf("size=%d marshal: %v", n, err)
+		}
+		var back MediaAttachment
+		if err := json.Unmarshal(b, &back); err != nil {
+			t.Fatalf("size=%d unmarshal: %v", n, err)
+		}
+		if len(back.Data) != n {
+			t.Fatalf("size=%d 往返后长度 = %d", n, len(back.Data))
+		}
+		for i := range data {
+			if back.Data[i] != data[i] {
+				t.Fatalf("size=%d 第 %d 字节损坏: %02x != %02x", n, i, back.Data[i], data[i])
+			}
+		}
+		if back.Name != att.Name || back.MIME != att.MIME || back.Digest != att.Digest {
+			t.Fatalf("size=%d 元数据往返不一致: %+v", n, back)
+		}
+	}
+}
+
+// omitempty 必须真的生效：读路径上内核不回 Data，若序列化仍产出 "data":null
+// 之类的键，跨进程消息会凭空变大，且插件侧无法区分"没有字节"与"空字节"。
+func TestStress_MediaTypesOmitEmpty(t *testing.T) {
+	cases := []struct {
+		name    string
+		v       interface{}
+		absent  []string
+		present []string
+	}{
+		{
+			name:    "Triple 无媒体",
+			v:       Triple{Subject: "甲方", Relation: "签署", Object: "合同"},
+			absent:  []string{"media_digests", "sentence_text", "confidence", "subject_type", "object_type"},
+			present: []string{"subject", "relation", "object"},
+		},
+		{
+			name:    "Triple 带媒体",
+			v:       Triple{Subject: "甲方", Relation: "包含", Object: "图", MediaDigests: []string{"abc12345"}, SentenceText: "句子"},
+			absent:  []string{"confidence"},
+			present: []string{"media_digests", "sentence_text"},
+		},
+		{
+			name:    "Doc 读路径无字节",
+			v:       Doc{ID: "d1", Title: "标题", Content: "正文", Attachments: []MediaAttachment{{Digest: "abc12345", MIME: "image/png"}}},
+			absent:  []string{"\"data\"", "media_digests", "score"},
+			present: []string{"attachments", "digest", "mime"},
+		},
+		{
+			name:    "TextEvent 无附件",
+			v:       TextEvent{Role: "user", Content: "hi"},
+			absent:  []string{"attachments", "channel"},
+			present: []string{"role", "content"},
+		},
+		{
+			name:    "ContentBlock 纯文本",
+			v:       ContentBlock{Type: "text", Text: "hi"},
+			absent:  []string{"image_url", "audio_url"},
+			present: []string{"type", "text"},
+		},
+		{
+			name:    "ContentBlock 图片",
+			v:       imageBlock("AAA"),
+			absent:  []string{"audio_url", "\"text\""},
+			present: []string{"image_url", "detail"},
+		},
+	}
+	for _, c := range cases {
+		b, err := json.Marshal(c.v)
+		if err != nil {
+			t.Fatalf("%s marshal: %v", c.name, err)
+		}
+		s := string(b)
+		for _, k := range c.absent {
+			if strings.Contains(s, k) {
+				t.Errorf("%s: 不该出现的键 %s —— %s", c.name, k, s)
+			}
+		}
+		for _, k := range c.present {
+			if !strings.Contains(s, k) {
+				t.Errorf("%s: 缺少键 %s —— %s", c.name, k, s)
+			}
+		}
+	}
+}
+
+// 媒体块在并发序列化下必须各自独立：ImageURL/AudioURL 是指针，
+// 若某处复用同一个指针再改写，序列化结果会互相污染。
+func TestStress_ContentBlockConcurrentMarshal(t *testing.T) {
+	const workers, rounds = 16, 300
+	var wg sync.WaitGroup
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < rounds; i++ {
+				tag := fmt.Sprintf("w%d-i%d", w, i)
+				blocks := []ContentBlock{
+					{Type: "text", Text: tag},
+					imageBlock(tag),
+					{Type: "audio_url", AudioURL: &AudioURL{URL: "data:audio/wav;base64," + tag}},
+				}
+				b, err := json.Marshal(blocks)
+				if err != nil {
+					t.Errorf("marshal: %v", err)
+					return
+				}
+				var back []ContentBlock
+				if err := json.Unmarshal(b, &back); err != nil {
+					t.Errorf("unmarshal: %v", err)
+					return
+				}
+				if len(back) != 3 {
+					t.Errorf("块数 = %d", len(back))
+					return
+				}
+				if back[0].ImageURL != nil || back[0].AudioURL != nil {
+					t.Errorf("文本块被填了媒体指针: %+v", back[0])
+				}
+				if back[1].ImageURL == nil || !strings.HasSuffix(back[1].ImageURL.URL, tag) {
+					t.Errorf("图片块 URL 错位: %+v", back[1].ImageURL)
+				}
+				if back[1].AudioURL != nil {
+					t.Errorf("图片块被填了音频指针")
+				}
+				if back[2].AudioURL == nil || !strings.HasSuffix(back[2].AudioURL.URL, tag) {
+					t.Errorf("音频块 URL 错位: %+v", back[2].AudioURL)
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+}
+
+// ---------- 8. 注册面的并发 ----------
+
+// 插件在 Start() 里起多个 goroutine 分别注册工具是常见写法。
+// def.Plugin 的默认填充若不是每次调用独立的，就会出现工具归属错乱——
+// 表现是 OwnTools scope 失效、WebUI 里工具挂在别的插件名下。
+func TestStress_RegisterToolConcurrentPluginDefaulting(t *testing.T) {
+	var mu sync.Mutex
+	got := map[string]string{} // toolName -> def.Plugin
+
+	s := &PluginSDK{
+		name: "mine",
+		regTool: func(name string, def ToolDef, h ToolHandler) error {
+			mu.Lock()
+			got[name] = def.Plugin
+			mu.Unlock()
+			return nil
+		},
+	}
+
+	const workers, perWorker = 16, 100
+	var wg sync.WaitGroup
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < perWorker; i++ {
+				name := fmt.Sprintf("tool_w%d_i%d", w, i)
+				def := ToolDef{Description: "d", Parameters: map[string]interface{}{}}
+				// 一半显式指定归属，一半靠 SDK 填默认值
+				if i%2 == 0 {
+					def.Plugin = "explicit"
+				}
+				if err := s.RegisterTool(name, def, func(map[string]interface{}) (interface{}, error) {
+					return nil, nil
+				}); err != nil {
+					t.Errorf("RegisterTool: %v", err)
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+
+	if len(got) != workers*perWorker {
+		t.Fatalf("注册工具数 = %d，期望 %d", len(got), workers*perWorker)
+	}
+	for name, owner := range got {
+		want := "mine"
+		if isEvenSuffix(name) {
+			want = "explicit"
+		}
+		if owner != want {
+			t.Fatalf("工具 %s 归属 = %q，期望 %q", name, owner, want)
+		}
+	}
+}
+
+// isEvenSuffix 判断 tool_wX_iY 里的 Y 是否为偶数。
+func isEvenSuffix(name string) bool {
+	idx := strings.LastIndex(name, "_i")
+	if idx < 0 {
+		return false
+	}
+	n := 0
+	if _, err := fmt.Sscanf(name[idx+2:], "%d", &n); err != nil {
+		return false
+	}
+	return n%2 == 0
+}
+
+// nil 依赖下所有便捷方法必须静默降级而非 panic。
+//
+// 这是"媒体存储可关闭"在 SDK 层的对应物：内核未注入某个 API 时
+// （精简部署、插件权限不足、子进程握手尚未完成），插件的调用不该崩。
+func TestStress_NilDependenciesDegradeSilently(t *testing.T) {
+	s := &PluginSDK{name: "bare"}
+
+	const workers = 16
+	var wg sync.WaitGroup
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for i := 0; i < 200; i++ {
+				s.InjectText("s", "c", "t")
+				s.InjectTextNoMemory("s", "c", "t")
+				s.InjectInterruptText("s", "c", "t")
+				if got := s.InjectInputSync("s", "c", "t"); got != "" {
+					t.Errorf("无 injector 时同步注入应返回空串，got %q", got)
+				}
+				s.InjectInputMedia("s", "c", "t", []ContentBlock{imageBlock("x")})
+				if got := s.InjectInputMediaSync("s", "c", "t", nil); got != "" {
+					t.Errorf("无 injector 时媒体同步注入应返回空串，got %q", got)
+				}
+				s.InjectInterruptMedia("s", "c", "t", nil)
+
+				// getter 全部应返回 nil 而非 panic
+				_ = s.Memory()
+				_ = s.TextMemory()
+				_ = s.DocMemory()
+				_ = s.Knowledge()
+				_ = s.LLM()
+				_ = s.Social()
+				_ = s.Events()
+				_ = s.PluginMgr()
+				_ = s.Settings()
+
+				// 注册面无 registrar 时应返回 nil error
+				if err := s.RegisterTool("t", ToolDef{}, nil); err != nil {
+					t.Errorf("无 registrar 时 RegisterTool 应返回 nil，got %v", err)
+				}
+				if err := s.RegisterPluginAPI("a"); err != nil {
+					t.Errorf("无 registrar 时 RegisterPluginAPI 应返回 nil，got %v", err)
+				}
+				s.RegisterStage(StageOnInput, func(*StageContext) error { return nil })
+			}
+		}()
+	}
+	wg.Wait()
+}

tools/hmapdev/cmd_build.go

@@ -20,11 +20,21 @@ type BuildConfig struct {
 	Replaces []string
 }
 
+// buildFailed 记录本次构建是否有平台失败。
+//
+// 为什么要它：这两个构建函数遇到错误只是 Printf 后 return，而 cmdBuild 返回
+// void，于是**构建失败却以 0 退出**。调用方（批量重编脚本、CI、发版脚本）
+// 只能靠翻日志发现失败——实测中一个示例的 windows 目标编译失败，脚本却报
+// 「17/17 全绿」，并因此少产出 16 个 .hmap。
+// 判成功要看退出码，不能靠人读日志。
+var buildFailed bool
+
 func cmdBuild(args []string) {
 	// Read all config from plg.json first
 	plg, err := readPlgJSON("plg.json")
 	if err != nil {
-		fmt.Printf("error: read plg.json: %v\n", err); os.Exit(1)
+		fmt.Printf("error: read plg.json: %v\n", err)
+		os.Exit(1)
 	}
 
 	// Base config from plg.json
@@ -39,11 +49,13 @@ func cmdBuild(args []string) {
 		switch args[i] {
 		case "--outdir":
 			if i+1 < len(args) {
-				outDir = args[i+1]; i++
+				outDir = args[i+1]
+				i++
 			}
 		case "--target":
 			if i+1 < len(args) {
-				targets = append(targets, args[i+1]); i++
+				targets = append(targets, args[i+1])
+				i++
 			}
 		case "--bundle":
 			bundle = true
@@ -51,11 +63,13 @@ func cmdBuild(args []string) {
 			bundle = false
 		case "--sdk-path":
 			if i+1 < len(args) {
-				sdkPath = args[i+1]; i++
+				sdkPath = args[i+1]
+				i++
 			}
 		case "--replace", "-R":
 			if i+1 < len(args) {
-				cliReplaces = append(cliReplaces, args[i+1]); i++
+				cliReplaces = append(cliReplaces, args[i+1])
+				i++
 			}
 		}
 	}
@@ -68,18 +82,9 @@ func cmdBuild(args []string) {
 	// Ensure go.mod exists with correct SDK path
 	sdkModule := ensureGoMod(plg, sdkPath)
 
-	// First build: fetch the SDK module (generates go.sum with zip hash)
+	// 保证 SDK 模块可解析，否则编译必死在 "missing go.sum entry"。
 	if sdkModule != "" {
-		if _, err := os.Stat("go.sum"); os.IsNotExist(err) {
-			dl := exec.Command("go", "mod", "download", sdkModule)
-			dl.Env = os.Environ()
-			dl.Stdout = os.Stdout
-			dl.Stderr = os.Stderr
-			fmt.Println("  downloading SDK module deps...")
-			if err := dl.Run(); err != nil {
-				fmt.Printf("  error: go mod download: %v\n", err)
-			}
-		}
+		ensureSDKResolvable(plg, sdkModule, sdkPath)
 	}
 
 	// Merge plg.json replaces + CLI overrides
@@ -96,23 +101,53 @@ func cmdBuild(args []string) {
 
 	if bundle || len(targets) == 0 {
 		buildBundle(plg, outDir, sdkPath)
-		return
+	} else {
+		for _, t := range targets {
+			buildTarget(plg, t, outDir, sdkPath)
+		}
 	}
 
-	for _, t := range targets {
-		buildTarget(plg, t, outDir, sdkPath)
+	// 以非零码退出：调用方（批量重编、CI、发版脚本）靠退出码判成败。
+	// 以前这里直接 return，失败也退 0，于是「构建失败」只能靠人翻日志发现——
+	// 实测中就因此把一次部分失败当成了全绿。
+	if buildFailed {
+		fmt.Println("error: 至少一个目标构建失败（详见上面日志）")
+		os.Exit(1)
 	}
 }
 
 // allBundleTargets 是 --bundle 模式构建的全部平台。
-// 每个 OS 只有一个架构（amd64），避免二进制文件名冲突。
+//
+// 子进程模式下各平台产物同名（plugin.bin）——进程边界即 ABI 边界，
+// 不存在平台特有扩展名，故 zip 内按平台加后缀区分；
+// 内核安装时按当前平台挑对应条目重命名为 plugin.bin。
+//
+// **不含 windows**：插件只能运行在 homed 能跑的平台上，而 homed 已明确放弃
+// Windows 原生支持（插件体系依赖 fd 继承 + 统一共享内存区的段内偏移，
+// Windows 句柄模型无法表达）。Windows 用户走 WSL2，而 WSL2 就是 linux/amd64。
 var allBundleTargets = []struct {
 	target string
 	entry  string // 二进制在 zip 中的文件名
 }{
-	{"linux/amd64", "plugin.so"},
-	{"darwin/amd64", "plugin.dylib"},
-	{"windows/amd64", "plugin.dll"},
+	{"linux/amd64", "plugin.bin.linux.amd64"},
+	{"darwin/amd64", "plugin.bin.darwin.amd64"},
+}
+
+// checkTargetSupported 在构建前拦下**已知不支持**的目标，给出可执行的报错。
+//
+// 为什么要有它：插件运行在 homed 的进程里，所以目标平台必须是 homed 能跑的。
+// homed 已放弃 Windows 原生（原因：插件依赖 fd 继承与统一共享内存区段内偏移，
+// Windows 句柄模型无法表达），却还去构建 windows 插件，结果是死在一句
+// 「undefined: attachUnifiedShm」——看起来像代码 bug，实际是平台策略。
+// 这里换成明确的结论，并且**不静默跳过**：静默跳过会让人以为产出的包里包含 windows。
+func checkTargetSupported(target string) error {
+	if strings.HasPrefix(target, "windows/") {
+		return fmt.Errorf("不支持 windows 插件目标：插件运行在 homed 内，" +
+			"而 homed 已放弃 Windows 原生支持（插件体系依赖 fd 继承与统一共享内存区" +
+			"段内偏移解引用，Windows 句柄模型无法表达）。Windows 请用 WSL2——" +
+			"它就是 linux/amd64，用 --target linux/amd64 即可")
+	}
+	return nil
 }
 
 func buildBundle(plg *PlgConfig, outDir string, sdkPath string) {
@@ -120,39 +155,49 @@ func buildBundle(plg *PlgConfig, outDir string, sdkPath string) {
 	buildDir := "build"
 	os.MkdirAll(buildDir, 0755)
 
-	// Auto-generate C ABI bridge for non-Windows
-	bridgeCleanup := generateBridge("")
-	defer bridgeCleanup()
+	runtimeCleanup, err := generateProcRuntime()
+	if err != nil {
+		fmt.Printf("  error: %v\n", err)
+		buildFailed = true
+		return
+	}
+	defer runtimeCleanup()
+
 	thirdpartCleanup := linkThirdpart(plg, "linux/amd64")
 	defer thirdpartCleanup()
 
 	var binaries []binEntry
 
 	for _, bt := range allBundleTargets {
+		if err := checkTargetSupported(bt.target); err != nil {
+			fmt.Printf("  error: %v\n", err)
+			buildFailed = true
+			return
+		}
 		cfg, errMsg := resolveBuild(bt.target)
 		if cfg == nil {
 			fmt.Printf("  error: %s\n", errMsg)
+			buildFailed = true
 			return
 		}
 
-		outPath := filepath.Join(buildDir, cfg.entryFile)
+		// 每平台产物落到独立路径，避免相互覆盖
+		outName := fmt.Sprintf("%s_%s_%s", cfg.entryFile, cfg.goos, cfg.goarch)
+		outPath := filepath.Join(buildDir, outName)
 
-		cmd := exec.Command("go", "build", "-buildmode=c-shared", "-o", outPath)
+		// 零 cgo：跨平台交叉编译不需目标平台 C 工具链
+		cmd := exec.Command("go", "build", "-trimpath", "-o", outPath)
 		cmd.Env = os.Environ()
-		cmd.Env = append(cmd.Env, "GOOS="+cfg.goos, "GOARCH="+cfg.goarch, "CGO_ENABLED=1")
-
-		if cfg.goos == "windows" {
-			cc := detectWindowsCC()
-			if cc != "" {
-				cmd.Env = append(cmd.Env, "CC="+cc)
-			}
-		}
-
+		cmd.Env = append(cmd.Env, "GOOS="+cfg.goos, "GOARCH="+cfg.goarch, "CGO_ENABLED=0")
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
-		fmt.Printf("  compiling %s/%s (-buildmode=c-shared)...\n", cfg.goos, cfg.goarch)
+
+		fmt.Printf("  compiling %s/%s (子进程模式，CGO_ENABLED=0)...\n", cfg.goos, cfg.goarch)
 		if err := cmd.Run(); err != nil {
+			// 单平台失败即整包失败：bundle 少一个平台就是个坏包，
+			// 却仍会生成 .hmap 让人以为打包成功。
 			fmt.Printf("  error: build %s/%s: %v\n", cfg.goos, cfg.goarch, err)
+			buildFailed = true
 			return
 		}
 		binaries = append(binaries, binEntry{src: outPath, zip: bt.entry})
@@ -168,7 +213,7 @@ func buildBundle(plg *PlgConfig, outDir string, sdkPath string) {
 	for p := range platforms {
 		plats = append(plats, p)
 	}
-	writePluginJSON(plg, plats, "plugin.so")
+	writePluginJSON(plg, plats, procEntryFile)
 
 	// package single .hmap with correctly named entries
 	hmapPath := filepath.Join(outDir, fmt.Sprintf("%s_bundle.hmap", toSnake(plg.NameEn)))
@@ -176,7 +221,10 @@ func buildBundle(plg *PlgConfig, outDir string, sdkPath string) {
 	fmt.Printf("  packaged %s\n", filepath.Base(hmapPath))
 }
 
-func (p *PlgConfig) IsLua() bool { return p.Entry == "main.lua" }
+// IsLua 判断是否为 Lua 插件（走解释器，不经过 Go 编译）。
+//
+// 这是 entry 字段唯一仍在使用的用途：Go 插件不再看 entry 值，一律产出 plugin.bin。
+func (p *PlgConfig) IsLua() bool { return p.Entry == luaEntryFile }
 
 func readPlgJSON(path string) (*PlgConfig, error) {
 	data, err := os.ReadFile(path)
@@ -228,9 +276,14 @@ func writePluginJSON(plg *PlgConfig, platforms []string, entry string) {
 type buildConfig struct {
 	goos      string
 	goarch    string
-	entryFile string // "plugin.so" or "plugin.dll"
+	entryFile string // 一律为 plugin.bin（进程边界即 ABI 边界，无平台特有扩展名）
 }
 
+// resolveBuild 解析目标平台。
+//
+// 全平台统一产出 plugin.bin：子进程模式下不存在 .so/.dylib/.dll 的区分，
+// 因为进程边界本身就是 ABI 边界——这正是三套独立 ABI 实现收敛为
+// 单一 RPC 实现的直接后果（§9.2：Windows 不再是能力退化的第三套实现）。
 func resolveBuild(target string) (*buildConfig, string) {
 	if target == "lua" || target == "" {
 		return nil, "lua"
@@ -245,14 +298,8 @@ func resolveBuild(target string) (*buildConfig, string) {
 	}
 
 	switch goos {
-	case "linux":
-		return &buildConfig{goos: goos, goarch: goarch, entryFile: "plugin.so"}, ""
-	case "darwin":
-		return &buildConfig{goos: goos, goarch: goarch, entryFile: "plugin.dylib"}, ""
-	case "freebsd":
-		return &buildConfig{goos: goos, goarch: goarch, entryFile: "plugin.so"}, ""
-	case "windows":
-		return &buildConfig{goos: goos, goarch: goarch, entryFile: "plugin.dll"}, ""
+	case "linux", "darwin", "freebsd", "windows":
+		return &buildConfig{goos: goos, goarch: goarch, entryFile: procEntryFile}, ""
 	default:
 		return nil, fmt.Sprintf("unsupported OS %q", goos)
 	}
@@ -333,6 +380,123 @@ func ensureGoMod(plg *PlgConfig, sdkPath string) string {
 	return sdkModule
 }
 
+// ensureSDKResolvable 保证 SDK 模块在编译前可解析。
+//
+// 为何需要这个函数：gitcode 的模块不在 proxy.golang.org 上。只要 go.mod
+// 里的 SDK 靠 require 版本号解析，而本地又没 go.sum 条目，go build 就报
+// "missing go.sum entry"；而原来那句 `go mod download <mod>` 会去公共 proxy
+// 拉一个永远拉不到的条目，超时后只打一行 warn 就继继编译，紧接着死在
+// 同一个错误上——新用户拿到的是两段无关的报错。
+//
+// 三级策略，按代价递增：
+//  1. go.mod 已有指向本地目录的 replace —— 什么都不用做（replace 到目录时
+//     go 不需要也不校验 go.sum）。
+//  2. 能定位到本机 SDK 源码 —— 写入 replace。这是存量项目（go.mod 旧、
+//     无 replace）的救场路径。
+//  3. 都不行 —— 跑 `go mod tidy`（带 -mod=mod）让它自己去试，失败则给
+//     可操作的提示而不是让用户去猜。
+func ensureSDKResolvable(plg *PlgConfig, sdkModule, sdkPath string) {
+	data, err := os.ReadFile("go.mod")
+	if err != nil {
+		return
+	}
+
+	// 策略 1：已有指向本地目录的 replace。
+	// replace 目标带 / 或 . 开头的才是路径；指向另一个模块的 replace 不算。
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "replace ") || !strings.Contains(line, sdkModule) {
+			continue
+		}
+		parts := strings.Fields(line)
+		if len(parts) < 4 {
+			continue
+		}
+		target := parts[3]
+		if strings.HasPrefix(target, ".") || strings.HasPrefix(target, "/") ||
+			strings.Contains(target, ":/") || strings.Contains(target, ":\\") {
+			return // 已指向本地目录，无需 go.sum
+		}
+	}
+
+	// 策略 2：能定位到本机 SDK 就写 replace。
+	// resolveSDKPath 失败会 os.Exit，所以只在能确定拿到路径时调用它背后的探测。
+	if root := findLocalSDK(sdkPath); root != "" {
+		if appendGoModReplace(sdkModule, root) {
+			fmt.Printf("  SDK 指向本机源码（已写入 go.mod replace）：%s\n", root)
+			return
+		}
+	}
+
+	// 策略 3：交给 go mod tidy。
+	if _, err := os.Stat("go.sum"); err == nil {
+		return // 已有 go.sum，不插手
+	}
+	fmt.Println("  解析 SDK 依赖（go mod tidy）...")
+	tidy := exec.Command("go", "mod", "tidy")
+	tidy.Env = append(os.Environ(), "GOFLAGS=-mod=mod")
+	if out, err := tidy.CombinedOutput(); err != nil {
+		fmt.Printf("  warn: go mod tidy 失败：%v\n", err)
+		if len(out) > 0 {
+			fmt.Printf("  %s\n", strings.TrimSpace(string(out)))
+		}
+		fmt.Printf("  提示：%s 不在公共 proxy 上。用以下任一方式指向本机 SDK：\n", sdkModule)
+		fmt.Printf("    hmapdev sdk install latest      # 装一份到 ~/.homeagent/hmapdev/sdk\n")
+		fmt.Printf("    hmapdev build --sdk-path <路径>  # 或直接指定源码目录\n")
+	}
+}
+
+// findLocalSDK 探测本机 SDK 源码根目录，找不到返回空串。
+//
+// 与 resolveSDKPath 的区别：后者找不到就 os.Exit，适合“必须有”的调用点；
+// 这里是“有则更好”的探测，不能把构建搞挂。
+func findLocalSDK(sdkPath string) string {
+	candidates := []string{}
+	if sdkPath != "" {
+		if abs, err := filepath.Abs(sdkPath); err == nil {
+			candidates = append(candidates, abs)
+		}
+	}
+	// hmapdev 自身所在位置往上三级（tools/hmapdev/hmapdev → SDK 根）
+	if self, err := os.Executable(); err == nil {
+		candidates = append(candidates, filepath.Dir(filepath.Dir(filepath.Dir(self))))
+	}
+	// hmapdev sdk use 选定的版本（复用 sdkStore()，含改名前的旧目录回退）
+	store := sdkStore()
+	if store != "" {
+		if d, err := os.ReadFile(filepath.Join(store, "current")); err == nil {
+			if ver := strings.TrimSpace(string(d)); ver != "" {
+				candidates = append(candidates, filepath.Join(store, ver))
+			}
+		}
+	}
+	for _, c := range candidates {
+		if c == "" {
+			continue
+		}
+		if _, err := os.Stat(filepath.Join(c, "sdk", "plugin.go")); err == nil {
+			return c
+		}
+	}
+	return ""
+}
+
+// appendGoModReplace 向 go.mod 追加一条 replace，成功返回 true。
+func appendGoModReplace(module, localPath string) bool {
+	data, err := os.ReadFile("go.mod")
+	if err != nil {
+		return false
+	}
+	abs, err := filepath.Abs(localPath)
+	if err != nil {
+		return false
+	}
+	abs = strings.ReplaceAll(abs, "\\", "/")
+	s := strings.TrimRight(string(data), "\r\n")
+	s += fmt.Sprintf("\n\nreplace %s => %s\n", module, abs)
+	return os.WriteFile("go.mod", []byte(s), 0644) == nil
+}
+
 func resolveSDKPath(sdkPath string) string {
 	if sdkPath != "" {
 		abs, _ := filepath.Abs(sdkPath)
@@ -342,7 +506,7 @@ func resolveSDKPath(sdkPath string) string {
 		fmt.Printf("error: --sdk-path %q not a valid SDK\n", sdkPath)
 		os.Exit(1)
 	}
-	// Detect from plugindev's own location (internal dev)
+	// Detect from hmapdev's own location (internal dev)
 	self, err := os.Executable()
 	if err == nil {
 		cand := filepath.Dir(filepath.Dir(filepath.Dir(self)))
@@ -350,14 +514,8 @@ func resolveSDKPath(sdkPath string) string {
 			return cand
 		}
 	}
-	// Active SDK via plugindev sdk use
-	store := os.Getenv("HOMEAGENT_SDK_DIR")
-	if store == "" {
-		home, _ := os.UserHomeDir()
-		if home != "" {
-			store = filepath.Join(home, ".homeagent", "plugindev", "sdk")
-		}
-	}
+	// Active SDK via hmapdev sdk use
+	store := sdkStore()
 	if store != "" {
 		if d, err := os.ReadFile(filepath.Join(store, "current")); err == nil {
 			ver := strings.TrimSpace(string(d))
@@ -369,7 +527,7 @@ func resolveSDKPath(sdkPath string) string {
 			}
 		}
 	}
-	fmt.Printf("error: cannot locate SDK. Use --sdk-path or 'plugindev sdk use'\n")
+	fmt.Printf("error: cannot locate SDK. Use --sdk-path or 'hmapdev sdk use'\n")
 	os.Exit(1)
 	return ""
 }
@@ -403,7 +561,7 @@ func buildTarget(plg *PlgConfig, target, outDir, sdkPath string) {
 		return
 	}
 
-	// Resolve build config
+	// Resolve build config（全平台统一产出 plugin.bin）
 	cfg, errMsg := resolveBuild(target)
 	if cfg == nil {
 		fmt.Printf("  error: %s\n", errMsg)
@@ -414,9 +572,19 @@ func buildTarget(plg *PlgConfig, target, outDir, sdkPath string) {
 	os.MkdirAll(buildDir, 0755)
 	outPath := filepath.Join(buildDir, cfg.entryFile)
 
-	// Auto-generate C ABI bridge (all platforms use c-shared)
-	bridgeCleanup := generateBridge(cfg.goos)
-	defer bridgeCleanup()
+	runtimeCleanup, err := generateProcRuntime()
+	if err != nil {
+		fmt.Printf("  error: %v\n", err)
+		return
+	}
+	defer runtimeCleanup()
+
+	// 已知未实现的目标在编译前拦下，给可执行的报错（见 checkTargetSupported）。
+	if err := checkTargetSupported(target); err != nil {
+		fmt.Printf("  error: %v\n", err)
+		buildFailed = true
+		return
+	}
 
 	// Auto-link thirdpart/ contents + source_dirs + replace targets
 	thirdpartCleanup := linkThirdpart(plg, target)
@@ -425,30 +593,18 @@ func buildTarget(plg *PlgConfig, target, outDir, sdkPath string) {
 	// Write plugin.json with the correct entry for this target
 	writePluginJSON(plg, nil, cfg.entryFile)
 
-	cmd := exec.Command("go", "build", "-buildmode=c-shared", "-o", outPath)
+	// 普通 go build + 零 cgo：交叉编译不再需要目标平台的 C 工具链
+	// （旧路径靠 detectWindowsCC 找 MinGW，现在整个问题消失）。
+	cmd := exec.Command("go", "build", "-trimpath", "-o", outPath)
 	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "GOOS="+cfg.goos, "GOARCH="+cfg.goarch, "CGO_ENABLED=1")
-
-	// Auto-detect MinGW gcc on Windows
-	if cfg.goos == "windows" {
-		cc := detectWindowsCC()
-		if cc != "" {
-			cmd.Env = append(cmd.Env, "CC="+cc)
-		}
-	}
-
+	cmd.Env = append(cmd.Env, "GOOS="+cfg.goos, "GOARCH="+cfg.goarch, "CGO_ENABLED=0")
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
-	// DEBUG: list files before building
-	entries, _ := os.ReadDir(".")
-	for _, e := range entries {
-		fmt.Printf("  [DEBUG] file: %s\n", e.Name())
-	}
-
-	fmt.Printf("  compiling %s/%s (-buildmode=c-shared)...\n", cfg.goos, cfg.goarch)
+	fmt.Printf("  compiling %s/%s (子进程模式，CGO_ENABLED=0)...\n", cfg.goos, cfg.goarch)
 	if err := cmd.Run(); err != nil {
 		fmt.Printf("  error: build %s/%s: %v\n", cfg.goos, cfg.goarch, err)
+		buildFailed = true
 		return
 	}
 
@@ -465,8 +621,8 @@ func buildTarget(plg *PlgConfig, target, outDir, sdkPath string) {
 }
 
 type binEntry struct {
-	src string // 磁盘路径，如 build/plugin.so
-	zip string // zip 中条目名，如 plugin.so
+	src string // 磁盘路径，如 build/plugin.bin
+	zip string // zip 中条目名，如 plugin.bin.linux.amd64
 }
 
 // createBundleHmap 创建包含多平台二进制的 bundle .hmap 文件。
@@ -566,72 +722,8 @@ func toSnake(s string) string {
 	return strings.ToLower(strings.ReplaceAll(s, " ", "_"))
 }
 
-// detectWindowsCC looks for a MinGW-w64 gcc on Windows for c-shared builds.
-func detectWindowsCC() string {
-	// Check CC from environment first
-	if cc := os.Getenv("CC"); cc != "" {
-		if _, err := exec.LookPath(cc); err == nil {
-			return cc
-		}
-	}
-	// Check common MinGW install paths
-	candidates := []string{
-		"C:\\mingw64\\bin\\gcc.exe",
-		"C:\\MinGW\\bin\\gcc.exe",
-		"C:\\msys64\\mingw64\\bin\\gcc.exe",
-		"C:\\Users\\21989\\AppData\\Local\\Temp\\mingw64\\mingw64\\bin\\gcc.exe",
-	}
-	// Also search PATH for gcc
-	if path, err := exec.LookPath("gcc"); err == nil {
-		return path
-	}
-	for _, c := range candidates {
-		if _, err := os.Stat(c); err == nil {
-			return c
-		}
-	}
-	return ""
-}
-
 // stripIncludeGuard strips preprocessor guards and C++ comments from a C header,
 // since these can confuse cgo's type resolution.
-// generateBridge generates the C ABI bridge files for non-Lua builds.
-// Returns a cleanup function to remove generated files.
-func generateBridge(goos string) func() {
-	const bridgeFile = "z_bridge_gen.go"
-	const cEntryFile = "z_entry.c"
-	os.Remove(bridgeFile)
-	os.Remove(cEntryFile)
-
-	var files []string
-
-	if goos == "windows" {
-		if err := os.WriteFile(bridgeFile, []byte(tmplBridge), 0644); err != nil {
-			fmt.Printf("  error: write bridge: %v\n", err)
-			return func() {}
-		}
-		files = append(files, bridgeFile)
-	} else {
-		if err := os.WriteFile(bridgeFile, []byte(tmplLinuxBridge), 0644); err != nil {
-			fmt.Printf("  error: write bridge: %v\n", err)
-			return func() {}
-		}
-		files = append(files, bridgeFile)
-		// Write C entry point file
-		if err := os.WriteFile(cEntryFile, []byte(tmplPluginInitC), 0644); err != nil {
-			fmt.Printf("  error: write C entry: %v\n", err)
-			return func() {}
-		}
-		files = append(files, cEntryFile)
-	}
-
-	return func() {
-		for _, f := range files {
-			os.Remove(f)
-		}
-	}
-}
-
 // linkThirdpart scans thirdpart/, source_dirs from plg.json, and replace target dirs
 // for source files, generating auto-import stubs. Returns cleanup function.
 func linkThirdpart(plg *PlgConfig, target string) func() {

tools/hmapdev/cmd_debug.go

@@ -7,12 +7,12 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/JianFeeeee/homeagent-sdk/tools/plugindev/yaegi"
+	"gitcode.com/JianFeeeee/homeagent-sdk/tools/hmapdev/yaegi"
 )
 
 // tmplLuaDebug is the temporary Lua debug script template
 const tmplLuaDebug = `-- HomeAgent Lua Plugin Debug
--- Generated by plugindev debug --lua
+-- Generated by hmapdev debug --lua
 sdk = require("sdk")
 local ok, plugin = pcall(dofile, "main.lua")
 if not ok then
@@ -115,7 +115,7 @@ func debugLua(dir, sdkPath, luaPath string) {
 	luaBin, err := exec.LookPath("lua")
 	if err != nil {
 		fmt.Println("error: lua interpreter not found in PATH")
-		fmt.Println("  install Lua 5.1+ or use plugindev build to compile your plugin")
+		fmt.Println("  install Lua 5.1+ or use hmapdev build to compile your plugin")
 		os.Exit(1)
 	}
 

tools/hmapdev/cmd_init.go

@@ -7,8 +7,6 @@ import (
 	"sort"
 	"strings"
 	"text/template"
-
-	"gitcode.com/JianFeeeee/homeagent-sdk/meta"
 )
 
 func (p *PlgConfig) ReplacesToSlice() []string {
@@ -62,25 +60,56 @@ type TemplateData struct {
 	SDKModule  string
 	SDKVersion string
 
-	// C ABI
-	CABIVersion int
-	CABIHeader  string
+	// SDKLocalPath 是本机 SDK 源码绝对路径，写入生成的 go.mod 作为 replace 目标。
+	//
+	// 为何必须写：gitcode 的模块不在 proxy.golang.org 上，只 require 一个
+	// 版本号的 go.mod 配上缺失的 go.sum，新用户第一次 `hmapdev build`
+	// 必定死在 "missing go.sum entry"，而 `go mod tidy` 又会去公共 proxy 拉
+	// 一个不存在的条目。有了本地 replace，go 完全不需要 go.sum 条目。
+	SDKLocalPath string
 }
 
 func cmdInit(args []string) {
 	if len(args) < 1 {
-		fmt.Println("Usage: plugindev init <name> [--lua]")
+		fmt.Println("Usage: hmapdev init <name> [--lua] [--type remotedevice]")
 		os.Exit(1)
 	}
 
 	name := args[0]
 	isLua := false
+	isRemoteDevice := false
 	for _, a := range args[1:] {
 		switch a {
 		case "--lua":
 			isLua = true
+		case "--type", "-t":
+			// handled in next iteration
 		}
 	}
+	// also check --type remotedevice as a single arg
+	for i, a := range args[1:] {
+		if a == "--type" || a == "-t" {
+			if i+1 < len(args[1:]) {
+				if args[1:][i+1] == "remotedevice" {
+					isRemoteDevice = true
+				}
+			}
+		}
+		if a == "--type=remotedevice" || a == "-t=remotedevice" {
+			isRemoteDevice = true
+		}
+	}
+
+	if isRemoteDevice && isLua {
+		fmt.Println("error: --type remotedevice and --lua are mutually exclusive")
+		os.Exit(1)
+	}
+
+	// Remote device projects use different scaffold
+	if isRemoteDevice {
+		scaffoldRemoteDevice(name)
+		return
+	}
 
 	dir := name
 	if _, err := os.Stat(dir); !os.IsNotExist(err) {
@@ -88,7 +117,12 @@ func cmdInit(args []string) {
 		os.Exit(1)
 	}
 
-	entry := "plugin.so"
+	// Go 插件统一产出 plugin.bin（v1.0.0 子进程模式）。
+	//
+	// 此前这里写 "plugin.so"，scaffold 出来的 plg.json 就带着一个已退场的
+	// entry 值，新手跟着模板走会误以为自己在做 C ABI 插件。
+	// build 实际不看这个值（只用它区分 Lua），但模板不应误导。
+	entry := "plugin.bin"
 	var targets string
 	if isLua {
 		entry = "main.lua"
@@ -112,20 +146,19 @@ func cmdInit(args []string) {
 			Tags:        []string{name},
 			Targets:     targets,
 		},
-		IsLua:       isLua,
-		CABIVersion: meta.CABINum,
-		CABIHeader:  tmplCABIHeader,
+		IsLua: isLua,
 	}
 
 	// Detect SDK info for Go plugin go.mod.
-	// 生成的 go.mod 只 require SDK 线上模块版本，不写本地路径 replace；
-	// 本地调试请用 `plugindev build --sdk-path <path>` 或手动加 replace。
+	// 生成的 go.mod 除 require 外还写一条指向本机 SDK 的 replace：
+	// 否则 scaffold 出来的项目第一次 build 必定失败（详见 SDKLocalPath 注释）。
 	if !isLua {
-		sdkMod, goVer, _, sdkVer := detectSDKInfo()
+		sdkMod, goVer, sdkRoot, sdkVer := detectSDKInfo()
 		data.ModulePath = name
 		data.GoVersion = goVer
 		data.SDKModule = sdkMod
 		data.SDKVersion = "v" + sdkVer
+		data.SDKLocalPath = strings.ReplaceAll(sdkRoot, "\\", "/")
 	}
 
 	if err := os.MkdirAll(dir, 0755); err != nil {
@@ -159,7 +192,7 @@ func cmdInit(args []string) {
 	if isLua {
 		fmt.Printf("  cd %s && lua main.lua  (standalone test)\n", dir)
 	}
-	fmt.Printf("  cd %s && plugindev build\n", dir)
+	fmt.Printf("  cd %s && hmapdev build\n", dir)
 }
 
 // detectSDKInfo reads the HomeAgent SDK's go.mod and meta to get module path, go version, and SDK version.
@@ -192,6 +225,57 @@ func detectSDKInfo() (modulePath, goVersion, sdkPath, sdkVersion string) {
 	return modulePath, goVersion, root, sdkVersion
 }
 
+// scaffoldRemoteDevice 创建远程设备适配器项目脚手架
+func scaffoldRemoteDevice(name string) {
+	dir := name
+	if _, err := os.Stat(dir); !os.IsNotExist(err) {
+		fmt.Printf("error: directory %q already exists\n", dir)
+		os.Exit(1)
+	}
+
+	nameEn := strings.Title(strings.ReplaceAll(name, "-", " "))
+
+	data := TemplateData{
+		Plg: PlgConfig{
+			Name:        name,
+			NameZh:      "中文名",
+			NameEn:      nameEn,
+			Version:     "0.1.0",
+			Description: name + " remote device adapter",
+			Author:      "HomeAgent",
+			Entry:       name,
+			Tags:        []string{name, "remotedevice"},
+		},
+	}
+
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		fmt.Printf("error: create dir: %v\n", err)
+		os.Exit(1)
+	}
+
+	// 写入 main.c
+	writeTemplate(filepath.Join(dir, "main.c"), tmplRemoteDeviceMain, data)
+
+	// 写入 CMakeLists.txt
+	writeTemplate(filepath.Join(dir, "CMakeLists.txt"), tmplRemoteDeviceCMake, data)
+
+	// 创建 SDK 目录（symlink/copy）
+	sdkSrc := filepath.Join("..", "remotedevice")
+	sdkDst := filepath.Join(dir, "ha_remotedevice")
+	if _, err := os.Stat(sdkDst); os.IsNotExist(err) {
+		// 尝试创建符号链接，失败则提示
+		if err := os.Symlink(sdkSrc, sdkDst); err != nil {
+			fmt.Printf("  note: could not create symlink to SDK, copy manually:\n")
+			fmt.Printf("    cp -r %s %s\n", sdkSrc, sdkDst)
+		}
+	}
+
+	fmt.Printf("Created remote device adapter project %q\n", dir)
+	fmt.Printf("  cd %s && mkdir build && cd build && cmake .. && make\n", dir)
+	fmt.Printf("  Or include as subdirectory in your project:\n")
+	fmt.Printf("    add_subdirectory(%s)\n", dir)
+}
+
 func writeTemplate(path, content string, data TemplateData) {
 	tmpl, err := template.New("").Parse(content)
 	if err != nil {

tools/hmapdev/cmd_sdk.go

@@ -14,7 +14,12 @@ import (
 	"time"
 )
 
-const sdkDirName = "plugindev/sdk"
+const sdkDirName = "hmapdev/sdk"
+
+// legacySDKDirName 是改名前的存储目录。工具链在 1.2.0 从 plugindev 改名 hmapdev；
+// 已装过旧版的机器上 SDK 仍在旧路径，直接换名会让它找不到已装 SDK
+// （表现为「没有活动版本」）。新目录不存在而旧目录存在时沿用旧目录。
+const legacySDKDirName = "plugindev/sdk"
 
 // sdkStore returns the root directory for stored SDK versions.
 func sdkStore() string {
@@ -26,7 +31,15 @@ func sdkStore() string {
 		fmt.Printf("error: cannot determine home directory: %v\n", err)
 		os.Exit(1)
 	}
-	return filepath.Join(home, ".homeagent", sdkDirName)
+	dir := filepath.Join(home, ".homeagent", sdkDirName)
+	if _, err := os.Stat(dir); err != nil {
+		if legacy := filepath.Join(home, ".homeagent", legacySDKDirName); legacy != "" {
+			if _, err := os.Stat(legacy); err == nil {
+				return legacy
+			}
+		}
+	}
+	return dir
 }
 
 func sdkCurrentDir() string {
@@ -50,13 +63,13 @@ func cmdSDK(args []string) {
 		cmdSDKList()
 	case "install":
 		if len(args) < 2 {
-			fmt.Println("Usage: plugindev sdk install <version>")
+			fmt.Println("Usage: hmapdev sdk install <version>")
 			os.Exit(1)
 		}
 		cmdSDKInstall(args[1])
 	case "use":
 		if len(args) < 2 {
-			fmt.Println("Usage: plugindev sdk use <version>")
+			fmt.Println("Usage: hmapdev sdk use <version>")
 			os.Exit(1)
 		}
 		cmdSDKUse(args[1])
@@ -72,7 +85,7 @@ func cmdSDK(args []string) {
 }
 
 func sdkHelp() {
-	fmt.Print(`Usage: plugindev sdk <command>
+	fmt.Print(`Usage: hmapdev sdk <command>
 
 Manage installed HomeAgent SDK versions.
 
@@ -85,9 +98,9 @@ Commands:
   latest                Show the latest available version from remote
 
 Examples:
-  plugindev sdk install v0.7.1
-  plugindev sdk install latest
-  plugindev sdk use v0.7.1
+  hmapdev sdk install v0.7.1
+  hmapdev sdk install latest
+  hmapdev sdk use v0.7.1
 `)
 }
 
@@ -127,7 +140,7 @@ func cmdSDKList() {
 		fmt.Printf("  %s %s\n", mark, v)
 	}
 	if current == "" {
-		fmt.Println("\nNo version active. Use 'plugindev sdk use <version>' to set one.")
+		fmt.Println("\nNo version active. Use 'hmapdev sdk use <version>' to set one.")
 	}
 }
 
@@ -292,7 +305,7 @@ func cmdSDKUse(version string) {
 	verDir := sdkVersionDir(version)
 	if _, err := os.Stat(verDir); os.IsNotExist(err) {
 		fmt.Printf("SDK version %s is not installed.\n", version)
-		fmt.Printf("Install it first: plugindev sdk install %s\n", version)
+		fmt.Printf("Install it first: hmapdev sdk install %s\n", version)
 		os.Exit(1)
 	}
 	setCurrentVersion(store, version)
@@ -305,7 +318,7 @@ func cmdSDKPath() {
 	current := resolveCurrentVersion(store)
 	if current == "" {
 		fmt.Println("No active SDK version set.")
-		fmt.Println("Use 'plugindev sdk use <version>' to set one.")
+		fmt.Println("Use 'hmapdev sdk use <version>' to set one.")
 		os.Exit(1)
 	}
 	fmt.Println(sdkVersionDir(current))
@@ -440,21 +453,21 @@ func parseSemver(tag string) [3]int {
 }
 
 // activeSDKRoot returns the path to the active SDK root.
-// It replaces the old runtime.Caller(0) approach so plugindev can work
+// It replaces the old runtime.Caller(0) approach so hmapdev can work
 // independently of its own build location.
 func activeSDKRoot() string {
 	store := sdkStore()
 	current := resolveCurrentVersion(store)
 	if current == "" {
 		fmt.Printf("error: no active SDK version set\n")
-		fmt.Printf("  Install one: plugindev sdk install latest\n")
-		fmt.Printf("  Or set one:  plugindev sdk use <version>\n")
+		fmt.Printf("  Install one: hmapdev sdk install latest\n")
+		fmt.Printf("  Or set one:  hmapdev sdk use <version>\n")
 		os.Exit(1)
 	}
 	root := sdkVersionDir(current)
 	if _, err := os.Stat(root); os.IsNotExist(err) {
 		fmt.Printf("error: active SDK version %s not found at %s\n", current, root)
-		fmt.Printf("  Reinstall: plugindev sdk install %s\n", current)
+		fmt.Printf("  Reinstall: hmapdev sdk install %s\n", current)
 		os.Exit(1)
 	}
 	return root

tools/hmapdev/go.mod

@@ -1,4 +1,4 @@
-module github.com/JianFeeeee/homeagent-sdk/tools/plugindev
+module gitcode.com/JianFeeeee/homeagent-sdk/tools/hmapdev
 
 go 1.21.0
 

tools/hmapdev/main.go

@@ -30,15 +30,20 @@ func help() {
 	fmt.Print(`HomeAgent Plugin Dev Tool
 
 Usage:
-  plugindev init <name>           Scaffold a new plugin project
-  plugindev build [flags]         Compile and package plugin
-  plugindev clean                 Clean build/dist artifacts
-  plugindev debug [dir]           Interpret and debug plugin source
-  plugindev sdk <command>         Manage SDK versions
+  hmapdev init <name>             Scaffold a new plugin project
+  hmapdev init <name> --lua       Create Lua plugin
+  hmapdev init <name> --type remotedevice
+                                    Create C remote device adapter
+  hmapdev build [flags]           Compile and package plugin
+  hmapdev clean                   Clean build/dist artifacts
+  hmapdev debug [dir]             Interpret and debug plugin source
+  hmapdev sdk <command>           Manage SDK versions
 
 Flags:
   --outdir    Output directory (default: dist)
   --target    Target OS/arch (e.g. linux/amd64), repeatable
   --lua       Create Lua plugin (for init)
+  --type      Project type: "remotedevice" (for init)
+  -t          Alias for --type
 `)
 }

tools/hmapdev/proc_runtime.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"embed"
+	"fmt"
+	"os"
+)
+
+// 子进程插件运行时（外部插件多进程化）。
+//
+// 模板为何是**真实 .go 源文件** + //go:embed，而不是 raw string：
+// 1100+ 行代码塞在字符串里写错只能等生成插件时才炸；作为源文件可被
+// gofmt / go vet / go/parser 直接检查（proc_runtime_test.go 的 16 项
+// 静态检查就以此为前提）。
+//
+// 构建从 `-buildmode=c-shared` + CGO_ENABLED=1 变成普通 `go build` +
+// CGO_ENABLED=0，交叉编译不再需要目标平台的 C 工具链（§3.1 连带消失项）。
+//
+// 设计依据：docs/zh/架构迁移评估.md §3、docs/zh/plugin-migration-plan.md Part 3/6
+
+//go:embed templates/proc_main.go.tmpl
+//go:embed templates/proc_shm_unix.go.tmpl
+//go:embed templates/proc_shm_windows.go.tmpl
+var procTemplates embed.FS
+
+// procRuntimeFiles 列出生成到插件目录的运行时文件。
+//
+// 共享段与事件通知的**传递机制**按平台不同（Unix 继承 fd，
+// Windows 命名内核对象），故拆成带 build tag 的两个文件；
+// 共享段**布局**与 RPC 逻辑完全平台无关，全在 proc_main 里。
+//
+// 这正是三套独立 ABI 实现收敛为单一 RPC 实现的效果：
+// 平台差异从「整套 stage 下发/写回逻辑各写一份」缩到「三个挂载函数」。
+var procRuntimeFiles = []struct {
+	tmpl string // 内嵌模板路径
+	out  string // 生成到插件目录的文件名
+}{
+	{"templates/proc_main.go.tmpl", "z_proc_gen.go"},
+	{"templates/proc_shm_unix.go.tmpl", "z_proc_shm_unix.go"},
+	{"templates/proc_shm_windows.go.tmpl", "z_proc_shm_windows.go"},
+}
+
+// procEntryFile 是子进程插件的入口二进制名（与内核 internal/plugin/dynamic.go 的 binEntry 一致）。
+//
+// 全平台同名：进程边界本身就是 ABI 边界，不存在平台特有的动态库扩展名
+// （对比 C ABI 时代的 .so/.dylib/.dll 三套产物 + 三套 ABI 实现）。
+const procEntryFile = "plugin.bin"
+
+// luaEntryFile 是 Lua 插件的入口。Lua 走解释器，不经过 Go 编译。
+const luaEntryFile = "main.lua"
+
+// procGenFile 是生成的主运行时文件名（兼容旧注释引用）。
+// 前缀 z_ 使其在目录列表中排在业务代码之后。
+const procGenFile = "z_proc_gen.go"
+
+// generateProcRuntime 把子进程运行时（平台无关主体 + 两个平台挂载实现）
+// 写入插件目录，返回清理函数。
+func generateProcRuntime() (func(), error) {
+	// 清理历史 C ABI 产物：旧版 hmapdev（原名 plugindev）生成过这两个文件，残留下来会与
+	// 本模板的 main 冲突。无需人工清理就能从旧版升级。
+	for _, stale := range []string{"z_bridge_gen.go", "z_entry.c"} {
+		os.Remove(stale)
+	}
+
+	var written []string
+	cleanup := func() {
+		for _, f := range written {
+			os.Remove(f)
+		}
+	}
+
+	for _, rf := range procRuntimeFiles {
+		data, err := procTemplates.ReadFile(rf.tmpl)
+		if err != nil {
+			cleanup()
+			return nil, fmt.Errorf("读取内嵌模板 %s: %w", rf.tmpl, err)
+		}
+		if err := os.WriteFile(rf.out, data, 0644); err != nil {
+			cleanup()
+			return nil, fmt.Errorf("写入 %s: %w", rf.out, err)
+		}
+		written = append(written, rf.out)
+	}
+	return cleanup, nil
+}
+
+// isProcEntry 已删除：Go 插件一律产出 plugin.bin，不再看 plg.json 的 entry 值。
+//
+// 为何忽略 entry：17 个存量插件的 plg.json 都写着 "plugin.so"。若把 entry 当作
+// 通道开关，迁移就得改 17 个文件——而「外部插件零改动」是本次迁移的硬约束。
+// entry 现在只用于区分 Lua（main.lua）与 Go 插件。

tools/hmapdev/proc_runtime_test.go

@@ -0,0 +1,462 @@
+package main
+
+import (
+	"go/parser"
+	"go/token"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// 子进程运行时模板的静态检查（Part 3）。
+//
+// 为什么需要这些测试：模板是插件的运行时半身，它与内核 internal/plugin/proc/
+// 的协议名、共享段布局、字段索引必须逐一对齐。任一处漂移都会导致
+// 「插件编译通过但运行时读错字段」——比编译错误难查得多。
+//
+// 模板改为真实 .go 源文件（而非 raw string）的直接收益就是这类检查可行。
+
+func loadProcTemplate(t *testing.T) string {
+	t.Helper()
+	data, err := procTemplates.ReadFile("templates/proc_main.go.tmpl")
+	if err != nil {
+		t.Fatalf("读取内嵌模板: %v", err)
+	}
+	return string(data)
+}
+
+// stripComments 去掉源码中的注释（用空白填充以保持偏移），只留可执行代码。
+func stripComments(t *testing.T, src string) string {
+	t.Helper()
+	fs := token.NewFileSet()
+	f, err := parser.ParseFile(fs, "proc_main.go", src, parser.ParseComments)
+	if err != nil {
+		t.Fatalf("解析模板: %v", err)
+	}
+	out := []byte(src)
+	for _, cg := range f.Comments {
+		s := fs.Position(cg.Pos()).Offset
+		e := fs.Position(cg.End()).Offset
+		for i := s; i < e && i < len(out); i++ {
+			if out[i] != '\n' {
+				out[i] = ' '
+			}
+		}
+	}
+	return string(out)
+}
+
+// 模板必须是合法 Go 源码。
+func TestProcTemplate_ParsesAsGo(t *testing.T) {
+	src := loadProcTemplate(t)
+	fs := token.NewFileSet()
+	if _, err := parser.ParseFile(fs, "proc_main.go", src, parser.AllErrors); err != nil {
+		t.Fatalf("模板不是合法 Go 源码: %v", err)
+	}
+}
+
+// 模板必须提供 main()，且不得含 cgo 痕迹。
+//
+// 零 cgo 是迁移的核心收益之一（§3.7 锁仲裁回内核后整个架构无 cgo）；
+// 一旦有人往模板里加 import "C"，交叉编译立刻退回需要目标平台 C 工具链。
+func TestProcTemplate_HasMainAndNoCgo(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	if !strings.Contains(src, "func main()") {
+		t.Error("子进程模板必须有 main() 入口")
+	}
+	// 只检查代码，不检查注释——模板顶部的说明文字本身就提到了 C.CString/C.free
+	code := stripComments(t, src)
+	for _, forbidden := range []string{
+		`import "C"`,
+		"//export ",
+		"C.CString",
+		"C.GoString",
+		"C.free",
+	} {
+		if strings.Contains(code, forbidden) {
+			t.Errorf("模板不应含 cgo 痕迹 %q（零 cgo 是迁移的核心收益）", forbidden)
+		}
+	}
+}
+
+// 模板引用的 method 名必须与内核 internal/plugin/proc/protocol.go 一致。
+//
+// 这里硬编码一份清单做对照：内核侧改了 method 名而模板没跟上时，
+// 表现是插件调用返回「未知 method」，测试能提前拦住。
+func TestProcTemplate_CoversAllCoreMethods(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	// 51 个 C ABI method id 平移后的名字（§3.2），加 stage 锁仲裁 2 个
+	required := []string{
+		// 注册面
+		"tool.register", "stage.register", "output.register", "api.register", "input.register",
+		// IO 注入（io.injectTextNoMem 见下方 deprecated：内核保留为兼容旧二进制，
+		// 当前模板改走 io.injectText + NoMemory 标志位，不再发那个 id）
+		"io.injectText", "io.injectInterrupt", "io.injectInputSync",
+		"io.setToolBlocks",
+		// 多模态注入（1.1.0 新增）。漏接线的后果是插件调 InjectInputMedia 静默无效果：
+		// 模板不发这个 RPC，内核也就永远收不到，而两边都不报错。
+		"io.injectMedia", "io.injectMediaSync", "io.injectInterruptMedia",
+		// 生命周期
+		"lifecycle.autoRestart",
+		// 图记忆
+		"memory.recall", "memory.commit", "memory.introspect", "memory.merge", "memory.purge",
+		// 文档记忆
+		"doc.query", "doc.insert", "doc.remove", "doc.stats",
+		// 文档媒体（1.1.0 新增）
+		"doc.insertWithMedia",
+		// 知识库
+		"knowledge.search", "knowledge.add", "knowledge.list",
+		// 文本记忆
+		"textmemory.append",
+		// 设置
+		"settings.get", "settings.set", "settings.registerDef",
+		"settings.getCore", "settings.setCore", "settings.listCore",
+		"settings.getPlugin", "settings.setPlugin", "settings.listPlugin",
+		"settings.list", "settings.defs", "settings.dump", "settings.plugins",
+		"settings.dataDir",
+		// LLM
+		"llm.listSources", "llm.setSource", "llm.currentSource",
+		// 社交图
+		"social.getPerson", "social.getNetwork", "social.getTrait",
+		"social.getRelations", "social.listPersons",
+		// 插件管理
+		"plugin.reloadOne", "plugin.listLoaded", "plugin.isDisabled",
+		// 共享段锁仲裁（新增，C ABI 下不存在此概念）
+		"stage.lock", "stage.unlock",
+	}
+	for _, m := range required {
+		if !strings.Contains(src, `"`+m+`"`) {
+			t.Errorf("模板缺少 core method %q（内核已提供，插件侧未接线）", m)
+		}
+	}
+
+	// 内核保留、但**当前模板不再发送**的 method id。
+	//
+	// 它们不是「公开接口新增却忘记接线」，而是刻意的向后兼容面：
+	// 内核必须继续接受用旧模板编出的插件二进制发来的 id，而当前模板没有理由再发。
+	//
+	// 可复查的判据：ba49dfd 之前的模板里 InjectTextNoMemory 发的就是
+	// "io.injectTextNoMem"；注入标志位落地后它改走 "io.injectText" + NoMemory。
+	//
+	// 为何要单独列而不是直接从 required 删掉：这条守卫的价值在于「新接口必须接线」，
+	// 而把「内核有、模板就必须发」当不变量，会让它常驻误报——常驻误报的守卫迟早
+	// 被人习惯性忽略，那时真漏接线也就没人看见了。
+	deprecated := map[string]string{
+		"io.injectTextNoMem": "旧模板经此表达「不进记忆」；现由 io.injectText + NoMemory 表达",
+	}
+	// 反向保护：allowlist 条目一旦又出现在模板里，说明它已过期，必须删掉，
+	// 否则这里会悄悄变成「永久豁免」的垃圾抽屉。
+	for m, why := range deprecated {
+		if strings.Contains(src, `"`+m+`"`) {
+			t.Errorf("deprecated 里的 %q 又出现在模板里（%s）——条目已过期，请从 deprecated 移除", m, why)
+		}
+	}
+}
+
+// 模板必须处理内核发来的全部调用（含无法 JSON 序列化的 Cleaner 回调）。
+func TestProcTemplate_HandlesAllKernelCalls(t *testing.T) {
+	src := loadProcTemplate(t)
+	for _, m := range []string{
+		"handshake",
+		"plugin.init", "plugin.start", "plugin.stop",
+		"tool.invoke", "cleaner.invoke", "stage.invoke", "output.invoke",
+	} {
+		if !strings.Contains(src, `case "`+m+`"`) {
+			t.Errorf("模板未处理内核调用 %q", m)
+		}
+	}
+}
+
+// 工具调用的 payload 必须走内核标定的**调用帧**（funccall 模型）。
+//
+// 共享内存是内核内部实现（插件作者只看到普通 map），但模板必须在传输层
+// 正确读写 frame / args_len / result_ref。漏接线的后果很隐蔽：参数被静默
+// 丢弃、结果只走内联，性能退化而不报错。
+func TestProcTemplate_ToolInvokeUsesSharedRef(t *testing.T) {
+	src := loadProcTemplate(t)
+	for _, want := range []string{"frame", "args_len", "result_ref"} {
+		if !strings.Contains(src, want) {
+			t.Errorf("模板的 tool.invoke 必须处理 %q（payload 走内核标定的调用帧）", want)
+		}
+	}
+}
+
+// 模板必须通过 arena.alloc / arena.free 向内核申请与归还共享内存。
+//
+// 共享内存是内核独占管理的**内部实现**：插件不能自己维护分配游标。
+// 历史上两版跨进程分配器（bump 游标 / 模板内位图 CAS）都因为把可变
+// 分配状态放在共享内存里而出竞态，所以这里做回归保护。
+func TestProcTemplate_UsesKernelArenaRPC(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	for _, m := range []string{`"arena.alloc"`, `"arena.free"`} {
+		if !strings.Contains(src, m) {
+			t.Errorf("模板缺少内核共享内存 RPC %s（插件必须向内核申请/归还）", m)
+		}
+	}
+
+	// 禁止插件侧再出现本地分配器符号。
+	//
+	// 只查代码不查注释：注释里会解释“为什么不再这么做”。
+	code := stripComments(t, src)
+	for _, forbidden := range []string{"arenaUsed", "arenaWrite"} {
+		if strings.Contains(code, forbidden) {
+			t.Errorf("模板不应再出现插件侧分配器 %q（共享内存由内核独占管理）", forbidden)
+		}
+	}
+}
+
+// 共享段布局常量必须与内核 internal/plugin/proc/shm.go 一致。
+//
+// 字段索引错位是最危险的漂移：插件会读到相邻字段的数据，
+// 而两边都不报错（同为 []byte）。
+func TestProcTemplate_ShmLayoutMatchesKernel(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	// 与内核 shm.go 的 offXxx 常量对齐（值比较，不依赖 gofmt 的对齐空白）
+	layout := map[string]string{
+		"shmOffMagic":     "0",
+		"shmOffVersion":   "4",
+		"shmOffArenaBase": "8",
+		"shmOffArenaCap":  "12",
+		"shmOffArenaUsed": "16",
+		"shmOffCtxBase":   "20",
+		"shmOffSeq":       "24",
+		// 与内核 stageFieldCount / sliceSize 对齐
+		"shmStageFieldCount": "18",
+		"shmSliceSize":       "8",
+		"shmVersion":         "1",
+	}
+	constRe := func(name, want string) bool {
+		// gofmt 会对齐常量块，故容许 name 与 = 之间有任意空白
+		re := regexp.MustCompile(`\b` + regexp.QuoteMeta(name) + `\s*=\s*` + regexp.QuoteMeta(want) + `\b`)
+		return re.MatchString(src)
+	}
+	for name, want := range layout {
+		if !constRe(name, want) {
+			t.Errorf("共享段常量 %s 应为 %s（须与内核 internal/plugin/proc/shm.go 一致）", name, want)
+		}
+	}
+
+	// 字段枚举顺序：内核 stageField 的前若干项
+	fieldOrder := []string{
+		"fRawMessage = iota", "fUserID", "fGroupID", "fLLMText",
+		"fReasoningContent", "fFinalText", "fResponse", "fPhase",
+		"fContextMsgs", "fToolCalls", "fToolResults", "fMemory",
+		"fTokenUsage", "fErrors",
+		"fExtraMediaBlocks", "fExtraMediaType", "fExtraInputSource", "fExtraOutputChannel",
+	}
+	idx := -1
+	for _, f := range fieldOrder {
+		at := strings.Index(src, f)
+		if at < 0 {
+			t.Fatalf("模板缺少字段常量 %s", f)
+		}
+		if at <= idx {
+			t.Errorf("字段常量 %s 的声明顺序与内核 stageField 枚举不一致", f)
+		}
+		idx = at
+	}
+}
+
+// stage 处理必须「拿锁 → 读 → handler → 只写脏字段 → 放锁」。
+//
+// 只写脏字段是消除 lost update 的核心：只读插件零写入，
+// 不可能覆盖其他插件的改写（对照 C ABI 副本模型实测 35.8~36.8% 丢失）。
+func TestProcTemplate_StageFlowUsesLockAndDirtyWrite(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	for _, want := range []string{
+		"func handleStageInvoke(",
+		"stage.lock",
+		"readStageContext()",
+		"takeStageSnapshot(",
+		"writeStageDirty(",
+		"stage.unlock",
+	} {
+		if !strings.Contains(src, want) {
+			t.Errorf("stage 处理链路缺少 %q", want)
+		}
+	}
+
+	// 顺序检查：加锁必须在读取之前，写回必须在解锁之前
+	iLock := strings.Index(src, `callCoreVoid("stage.lock"`)
+	iRead := strings.Index(src, "readStageContext()")
+	iWrite := strings.Index(src, "writeStageDirty(sc, snap)")
+	if iLock < 0 || iRead < 0 || iWrite < 0 {
+		t.Fatal("stage 链路关键调用缺失")
+	}
+	// readStageContext 的定义在前，调用在后；取 handleStageInvoke 内的位置
+	stageFn := src[strings.Index(src, "func handleStageInvoke("):]
+	iLockFn := strings.Index(stageFn, `callCoreVoid("stage.lock"`)
+	iReadFn := strings.Index(stageFn, "readStageContext()")
+	iWriteFn := strings.Index(stageFn, "writeStageDirty(sc, snap)")
+	if !(iLockFn < iReadFn && iReadFn < iWriteFn) {
+		t.Error("stage 链路顺序应为 加锁 → 读取 → 写回")
+	}
+}
+
+// 快照必须存序列化字符串而非 Go 值。
+//
+// ❗ 这是修 C ABI 侧 11.3 时踩过的坑：StageContext 的切片字段与读出的值
+// 共享底层内容，handler 原地改元素（sc.ToolResults[0].Result = x）时，
+// 直接持有 Go 值的快照会跟着变，脏字段计算失效、修复静默失效。
+func TestProcTemplate_SnapshotStoresSerializedStrings(t *testing.T) {
+	src := loadProcTemplate(t)
+
+	if !strings.Contains(src, "strs        map[int]string") ||
+		!strings.Contains(src, "jsons       map[int]string") {
+		t.Error("stageSnapshot 必须存序列化字符串（切片共享底层数组，存 Go 值会让脏字段计算失效）")
+	}
+	if !strings.Contains(src, "json.Marshal(v)") {
+		t.Error("takeStageSnapshot 应对容器字段做 json.Marshal")
+	}
+}
+
+// arena 用尽必须显式报错，不得静默截断（§4.4 风险登记）。
+func TestProcTemplate_ArenaExhaustionErrors(t *testing.T) {
+	src := loadProcTemplate(t)
+	if !strings.Contains(src, "arena 空间不足") {
+		t.Error("shmWrite 在 arena 不足时必须报错，不得静默截断")
+	}
+}
+
+// 日志必须走 stderr：stdout 是 RPC 通道，写日志会破坏 NDJSON 帧。
+func TestProcTemplate_LogsToStderr(t *testing.T) {
+	src := loadProcTemplate(t)
+	if !strings.Contains(src, "log.SetOutput(os.Stderr)") {
+		t.Error("日志必须走 stderr，否则会破坏 stdout 的 RPC 帧")
+	}
+}
+
+// 请求必须在独立 goroutine 里处理。
+//
+// handler 内会反向调用内核并等应答；若在读循环里同步处理，
+// 就没人读应答帧 → 死锁。
+func TestProcTemplate_DispatchesRequestsConcurrently(t *testing.T) {
+	src := loadProcTemplate(t)
+	if !strings.Contains(src, "go handleKernelRequest(&req)") {
+		t.Error("请求须在独立 goroutine 处理（handler 内反向调用内核，同步处理会死锁）")
+	}
+}
+
+// 协议与共享内存区域版本/魔数不匹配必须拒绝，不得半兼容运行。
+func TestProcTemplate_RejectsVersionMismatch(t *testing.T) {
+	src := loadProcTemplate(t)
+	// §13.1 起共享段合并为单一「统一区域」，魔数校验文案随之更新。
+	for _, want := range []string{"协议版本不匹配", "共享段版本不匹配", "统一区域魔数不匹配"} {
+		if !strings.Contains(src, want) {
+			t.Errorf("握手应校验并拒绝 %q", want)
+		}
+	}
+}
+
+// 全平台统一产出 plugin.bin。
+//
+// 这是三套独立 ABI 实现（.so/.dylib/.dll）收敛为单一 RPC 实现的直接后果：
+// 进程边界本身就是 ABI 边界，不存在平台特有的动态库扩展名。
+// §9.2 记录的「Windows DLL 路径只下发 3 字段、无写回」随之消失——
+// Windows 走的是与 Linux 完全相同的 RPC 实现。
+func TestResolveBuild_AllPlatformsProduceBin(t *testing.T) {
+	for _, target := range []string{
+		"linux/amd64", "linux/arm64",
+		"darwin/amd64", "darwin/arm64",
+		"windows/amd64",
+		"freebsd/amd64",
+	} {
+		cfg, errMsg := resolveBuild(target)
+		if cfg == nil {
+			t.Fatalf("resolveBuild(%q) 失败: %s", target, errMsg)
+		}
+		if cfg.entryFile != procEntryFile {
+			t.Errorf("%s: 产物应为 %s，实际 %s", target, procEntryFile, cfg.entryFile)
+		}
+	}
+}
+
+// lua 目标仍走解释器路径（entry 字段唯一仍在使用的用途）。
+func TestResolveBuild_LuaIsSeparatePath(t *testing.T) {
+	for _, target := range []string{"lua", ""} {
+		cfg, kind := resolveBuild(target)
+		if cfg != nil {
+			t.Errorf("%q 应返回 nil cfg（Lua 不经 Go 编译）", target)
+		}
+		if kind != "lua" {
+			t.Errorf("%q 应识别为 lua，实际 %q", target, kind)
+		}
+	}
+}
+
+// 不支持的平台明确报错，不静默产出错误产物。
+func TestResolveBuild_UnsupportedOSErrors(t *testing.T) {
+	cfg, errMsg := resolveBuild("plan9/amd64")
+	if cfg != nil {
+		t.Error("不支持的平台应返回 nil cfg")
+	}
+	if !strings.Contains(errMsg, "unsupported") {
+		t.Errorf("应给出 unsupported 提示，实际 %q", errMsg)
+	}
+}
+
+// bundle 产物在 zip 内按平台加后缀（全平台同名 plugin.bin 会相互覆盖）。
+func TestBundleTargets_HavePlatformSuffixedEntries(t *testing.T) {
+	seen := map[string]bool{}
+	for _, bt := range allBundleTargets {
+		if seen[bt.entry] {
+			t.Errorf("zip 条目名重复: %s（会相互覆盖）", bt.entry)
+		}
+		seen[bt.entry] = true
+		if !strings.HasPrefix(bt.entry, procEntryFile+".") {
+			t.Errorf("bundle 条目 %q 应以 %s. 为前缀", bt.entry, procEntryFile)
+		}
+	}
+	if len(allBundleTargets) == 0 {
+		t.Error("bundle 目标表不应为空")
+	}
+}
+
+// C ABI 工具链残留必须彻底清除：不得再有 .so/.dylib/.dll 产物路径，
+// 也不得再引用 c-shared 构建模式或 MinGW 探测。
+func TestToolchain_NoCABIResiduals(t *testing.T) {
+	for _, f := range []string{"cmd_build.go", "templates.go", "cmd_init.go", "proc_runtime.go"} {
+		data, err := os.ReadFile(f)
+		if err != nil {
+			t.Fatalf("读 %s: %v", f, err)
+		}
+		src := stripComments(t, string(data))
+		for _, forbidden := range []string{
+			"c-shared",
+			"CGO_ENABLED=1",
+			"detectWindowsCC",
+			"generateBridge",
+			"tmplLinuxBridge",
+			"tmplPluginInitC",
+		} {
+			if strings.Contains(src, forbidden) {
+				t.Errorf("%s 仍含 C ABI 残留 %q", f, forbidden)
+			}
+		}
+	}
+}
+
+// Go 插件的构建不再读 plg.json 的 entry 值。
+//
+// 这是「外部插件零改动」的关键：17 个存量插件的 plg.json 都写着 "plugin.so"，
+// 若把 entry 当通道开关，迁移就得改 17 个文件。
+func TestToolchain_IgnoresEntryForGoPlugins(t *testing.T) {
+	data, err := os.ReadFile("cmd_build.go")
+	if err != nil {
+		t.Fatalf("读 cmd_build.go: %v", err)
+	}
+	src := stripComments(t, string(data))
+	if strings.Contains(src, "isProcEntry") {
+		t.Error("isProcEntry 应已删除——Go 插件一律产出 plugin.bin，不看 entry 值")
+	}
+	// entry 仅剩 Lua 判定这一处用途
+	if !strings.Contains(src, "luaEntryFile") {
+		t.Error("IsLua 应改用 luaEntryFile 常量")
+	}
+}

tools/hmapdev/stagediff_test.go

@@ -0,0 +1,247 @@
+package main
+
+import (
+	"encoding/json"
+	"testing"
+
+	sdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
+)
+
+// 本测试验证 tmplLinuxBridge 中 snapshotWritable + changedFieldsOnly 的语义（plan.md 11.3）。
+// 模板字符串本身无法直接单测，这里以同一份逻辑复刻，防止回归。
+// ❗ 模板与本文件须同步修改。
+//
+// 关键陷阱（第一版实现踩过）：stageContextWritable 返回的切片字段与 sc 共享底层数组，
+// handler 原地改元素时"before 快照"会跟着变，diff 看不到变更 → 修复静默失效。
+// 故 before 必须是**序列化后的字符串快照**。
+
+func writable(sc *sdk.StageContext) map[string]interface{} {
+	m := map[string]interface{}{
+		"raw_message": sc.RawMessage,
+		"user_id":     sc.UserID,
+		"group_id":    sc.GroupID,
+		"phase":       string(sc.Phase),
+		"llm_text":    sc.LLMText,
+		"final_text":  sc.FinalText,
+		"no_memory":   sc.NoMemory,
+	}
+	if sc.Response != nil {
+		m["response"] = *sc.Response
+	}
+	if len(sc.ToolCalls) > 0 {
+		m["tool_calls"] = sc.ToolCalls
+	}
+	if len(sc.ToolResults) > 0 {
+		m["tool_results"] = sc.ToolResults
+	}
+	return m
+}
+
+// snapshot 对应模板里的 snapshotWritable：逐字段序列化为不可变快照。
+func snapshot(sc *sdk.StageContext) map[string]string {
+	snap := map[string]string{}
+	for k, v := range writable(sc) {
+		b, err := json.Marshal(v)
+		if err != nil {
+			continue
+		}
+		snap[k] = string(b)
+	}
+	return snap
+}
+
+// diffOnly 对应模板里的 changedFieldsOnly。
+func diffOnly(before map[string]string, after map[string]interface{}) map[string]interface{} {
+	diff := map[string]interface{}{}
+	keys := map[string]bool{}
+	for k := range before {
+		keys[k] = true
+	}
+	for k := range after {
+		keys[k] = true
+	}
+	for k := range keys {
+		bRaw, bHas := before[k]
+		a, aHas := after[k]
+		switch {
+		case aHas && !bHas:
+			diff[k] = a
+		case aHas && bHas:
+			ab, _ := json.Marshal(a)
+			if bRaw != string(ab) {
+				diff[k] = a
+			}
+		case bHas && !aHas:
+			switch k {
+			case "tool_calls":
+				diff[k] = []sdk.ToolCall{}
+			case "tool_results":
+				diff[k] = []sdk.ToolResult{}
+			}
+		}
+	}
+	return diff
+}
+
+// 只读插件（如 weather 的 AfterToolcall）不改任何字段 → 零回传。
+// 这是修复 lost update 的关键：旧实现会回传它收到的旧快照，覆盖 sanitizer 的清洗结果。
+func TestChangedFieldsOnly_ReadOnlyPluginReturnsNothing(t *testing.T) {
+	sc := &sdk.StageContext{
+		RawMessage: "hello",
+		LLMText:    "world",
+		ToolResults: []sdk.ToolResult{
+			{CallID: "c1", Name: "weather_query", Success: true, Result: "已清洗结果"},
+		},
+	}
+	before := snapshot(sc)
+	// 只读 handler：读了但没改
+	_ = sc.ToolResults[0].Result
+	diff := diffOnly(before, writable(sc))
+
+	if len(diff) != 0 {
+		t.Fatalf("只读插件应零回传，实际回传 %d 个字段: %v", len(diff), diff)
+	}
+}
+
+// 改写插件（如 sanitizer 改 ToolResults）→ 只回传被改的字段。
+// ⚠️ 这里是原地改切片元素，正是共享底层数组陷阱的触发场景。
+func TestChangedFieldsOnly_WriterReturnsOnlyChanged(t *testing.T) {
+	sc := &sdk.StageContext{
+		RawMessage: "hello",
+		LLMText:    "world",
+		ToolResults: []sdk.ToolResult{
+			{CallID: "c1", Name: "weather_query", Success: true, Result: "带\x1b[31mANSI\x1b[0m脏数据"},
+		},
+	}
+	before := snapshot(sc)
+	// sanitizer handler：原地清洗 ToolResults
+	sc.ToolResults[0].Result = "带ANSI脏数据"
+	diff := diffOnly(before, writable(sc))
+
+	if len(diff) != 1 {
+		t.Fatalf("应只回传 tool_results 一个字段，实际 %d 个: %v", len(diff), diff)
+	}
+	if _, ok := diff["tool_results"]; !ok {
+		t.Fatalf("回传字段应为 tool_results，实际 %v", diff)
+	}
+	// raw_message / llm_text 未改，不应出现（否则会覆盖其他插件的改写）
+	if _, ok := diff["raw_message"]; ok {
+		t.Error("raw_message 未改却被回传（会覆盖其他插件的改写）")
+	}
+	if _, ok := diff["llm_text"]; ok {
+		t.Error("llm_text 未改却被回传")
+	}
+}
+
+// 改写标量字段（如 before_output 改 FinalText）→ 只回传该字段。
+func TestChangedFieldsOnly_ScalarChange(t *testing.T) {
+	sc := &sdk.StageContext{
+		RawMessage: "hi",
+		FinalText:  "  带空白的回复  ",
+		LLMText:    "原始",
+	}
+	before := snapshot(sc)
+	sc.FinalText = "带空白的回复"
+	diff := diffOnly(before, writable(sc))
+
+	if len(diff) != 1 || diff["final_text"] != "带空白的回复" {
+		t.Fatalf("应只回传 final_text，实际 %v", diff)
+	}
+}
+
+// 首次设置 response（短路）→ 回传。
+func TestChangedFieldsOnly_NewResponseIsReturned(t *testing.T) {
+	sc := &sdk.StageContext{RawMessage: "hi"}
+	before := snapshot(sc)
+	resp := "被插件短路"
+	sc.Response = &resp
+	diff := diffOnly(before, writable(sc))
+
+	if v, ok := diff["response"]; !ok || v != "被插件短路" {
+		t.Fatalf("新设置的 response 应回传，实际 %v", diff)
+	}
+}
+
+// 清空切片字段 → 显式回传空值让内核跟随。
+func TestChangedFieldsOnly_ClearedSliceIsReturnedAsEmpty(t *testing.T) {
+	sc := &sdk.StageContext{
+		ToolCalls: []sdk.ToolCall{{ID: "t1", Name: "cmd_run"}},
+	}
+	before := snapshot(sc)
+	sc.ToolCalls = nil // 插件拒绝了全部工具调用
+	diff := diffOnly(before, writable(sc))
+
+	v, ok := diff["tool_calls"]
+	if !ok {
+		t.Fatalf("清空 tool_calls 应显式回传空值，实际 %v", diff)
+	}
+	if arr, _ := v.([]sdk.ToolCall); len(arr) != 0 {
+		t.Fatalf("应回传空切片，实际 %v", v)
+	}
+}
+
+// 复刻现网场景（实验 13）：sanitizer 清洗后 weather 只读回传，清洗结果不得被覆盖。
+// 旧实现下 weather 会回传自己收到的旧快照（含脏数据），覆盖 sanitizer 的清洗（丢失率 1.6~4.3%）。
+func TestChangedFieldsOnly_ProductionScenarioNoOverwrite(t *testing.T) {
+	dirty := "天气：晴 \x1b[31m28°C\x1b[0m"
+	clean := "天气：晴 28°C"
+
+	// 内核下发的原始快照（两插件各拿到一份副本）
+	kernelSnapshot := map[string]interface{}{
+		"raw_message":  "查天气",
+		"llm_text":     "",
+		"final_text":   "",
+		"user_id":      "u1",
+		"group_id":     "",
+		"phase":        "after_toolcall",
+		"no_memory":    false,
+		"tool_results": []sdk.ToolResult{{CallID: "c1", Name: "weather_query", Result: dirty}},
+	}
+
+	// sanitizer 副本：清洗
+	scSan := &sdk.StageContext{
+		RawMessage:  "查天气",
+		UserID:      "u1",
+		Phase:       sdk.StageAfterToolcall,
+		ToolResults: []sdk.ToolResult{{CallID: "c1", Name: "weather_query", Result: dirty}},
+	}
+	beforeSan := snapshot(scSan)
+	scSan.ToolResults[0].Result = clean
+	diffSan := diffOnly(beforeSan, writable(scSan))
+
+	// weather 副本：只读，不改
+	scWea := &sdk.StageContext{
+		RawMessage:  "查天气",
+		UserID:      "u1",
+		Phase:       sdk.StageAfterToolcall,
+		ToolResults: []sdk.ToolResult{{CallID: "c1", Name: "weather_query", Result: dirty}},
+	}
+	beforeWea := snapshot(scWea)
+	diffWea := diffOnly(beforeWea, writable(scWea))
+
+	// weather 必须零回传，否则它的旧快照会覆盖 sanitizer 的清洗
+	if len(diffWea) != 0 {
+		t.Fatalf("weather 只读却回传 %v —— 会覆盖 sanitizer 清洗结果", diffWea)
+	}
+	// sanitizer 必须回传 tool_results
+	if _, ok := diffSan["tool_results"]; !ok {
+		t.Fatalf("sanitizer 改写了 tool_results 却未回传：%v", diffSan)
+	}
+
+	// 内核按 sanitizer → weather 顺序应用 diff（weather 后到，是最坏情形）
+	kernel := map[string]interface{}{}
+	for k, v := range kernelSnapshot {
+		kernel[k] = v
+	}
+	for k, v := range diffSan {
+		kernel[k] = v
+	}
+	for k, v := range diffWea {
+		kernel[k] = v
+	}
+
+	res, _ := kernel["tool_results"].([]sdk.ToolResult)
+	if len(res) == 0 || res[0].Result != clean {
+		t.Fatalf("清洗结果被覆盖：期望 %q，实际 %v", clean, kernel["tool_results"])
+	}
+}

tools/hmapdev/templates.go

@@ -0,0 +1,520 @@
+package main
+
+// tmplPlgJSON is the plg.json template
+const tmplPlgJSON = `{
+  "name": "{{.Plg.Name}}",
+  "name_zh": "{{.Plg.NameZh}}",
+  "name_en": "{{.Plg.NameEn}}",
+  "version": "{{.Plg.Version}}",
+  "description": "{{.Plg.Description}}",
+  "author": "{{.Plg.Author}}",
+  "entry": "{{.Plg.Entry}}",
+  "tags": [{{range $i, $t := .Plg.Tags}}{{if $i}}, {{end}}"{{$t}}"{{end}}],
+  "targets": "{{.Plg.Targets}}"
+}
+`
+
+const tmplGoMod = `module {{.ModulePath}}
+
+go {{.GoVersion}}
+
+require {{.SDKModule}} {{.SDKVersion}}
+{{if .SDKLocalPath}}
+// SDK 指向本机源码。gitcode 的模块不在 proxy.golang.org 上，
+// 没有这条 replace 就需要 go.sum 条目，而那个条目无处可拉。
+// 若你已有可访问的私有 proxy，可删掉本行。
+replace {{.SDKModule}} => {{.SDKLocalPath}}
+{{end}}`
+
+const tmplPluginGo = `package main
+
+import (
+	"fmt"
+	"gitcode.com/JianFeeeee/homeagent-sdk/sdk"
+)
+
+type Plugin struct {
+	name string
+	sdk  *sdk.PluginSDK
+}
+
+func (p *Plugin) Name() string { return p.name }
+
+func (p *Plugin) Start(s *sdk.PluginSDK) error {
+	p.sdk = s
+	s.RegisterStopHandler(func() { fmt.Printf("[%s] stop handler running\n", p.name) })
+	s.Settings().RegisterDef(sdk.ConfigDef{
+		Key: "plugin.{{.Plg.Name}}.example", Default: "hello", Type: "string",
+		DisplayName: "示例配置", Description: "An example configuration key",
+		Category: "{{.Plg.Name}}",
+	})
+	tp := p.name + "_"
+	s.RegisterTool(tp+"hello", sdk.ToolDef{
+		Name:        tp + "hello",
+		Description: "A hello world tool",
+		Parameters:  map[string]interface{}{"type": "object", "properties": map[string]interface{}{}},
+		NoMemory:    false, // 工具输出对 LLM 注意力有信号价值时为 false，纯操作工具为 true
+		// Cleaner: func(output string) string {
+		//     // 工具输出参与向量化/jieba/蒸馏前，在此过滤噪音
+		//     return output
+		// },
+	}, p.handleHello)
+	fmt.Printf("[%s] started\n", p.name)
+	return nil
+}
+
+func (p *Plugin) Stop() error { fmt.Printf("[%s] stopped\n", p.name); return nil }
+
+func (p *Plugin) handleHello(args map[string]interface{}) (interface{}, error) {
+	return map[string]interface{}{"content": "Hello from {{.Plg.Name}} plugin!"}, nil
+}
+
+func NewPluginFactory(name string, config map[string]interface{}) (sdk.Plugin, error) {
+	return &Plugin{name: name}, nil
+}
+`
+
+const tmplSDKLua = `-- HomeAgent Lua Plugin SDK (standalone mock)
+sdk = {}
+function sdk.log(level, msg) print("[lua-plugin] " .. tostring(level) .. ": " .. tostring(msg)) end
+function sdk.register_tool(name, def, handler) print("[lua-plugin] register_tool: " .. tostring(name)) end
+function sdk.register_stage(stage, handler, scope) print("[lua-plugin] register_stage: " .. tostring(stage) .. " scope=" .. tostring(scope)) end
+function sdk.register_api(name) print("[lua-plugin] register_api: " .. tostring(name)) end
+function sdk.register_output_channel(name, caps, desc, def, handler) print("[lua-plugin] register_output_channel: " .. tostring(name)) end
+function sdk.register_input_channel(name, def) print("[lua-plugin] register_input_channel: " .. tostring(name)) end
+function sdk.get_setting(key) return nil end
+function sdk.set_setting(key, value) print("[lua-plugin] set_setting: " .. tostring(key)) end
+function sdk.inject_text(source, channel, text) print("[lua-plugin] inject_text: " .. tostring(source)) end
+function sdk.inject_interrupt(source, channel, text) print("[lua-plugin] inject_interrupt: " .. tostring(source)) end
+function sdk.inject_text_no_memory(source, channel, text) print("[lua-plugin] inject_text_no_memory: " .. tostring(source)) end
+function sdk.set_auto_restart(enabled) print("[lua-plugin] set_auto_restart: " .. tostring(enabled)) end
+sdk.memory = {}
+function sdk.memory.recall(query, depth) return {entities={}, relations={}} end
+function sdk.memory.commit(triples) return nil end
+function sdk.memory.introspect() return {} end
+function sdk.memory.merge(source, target) return 0 end
+function sdk.memory.purge(criteria, hard) return 0 end
+sdk.doc = {}
+function sdk.doc.query(text, top_k) return {} end
+function sdk.doc.insert(doc) return nil end
+function sdk.doc.remove(id) return nil end
+function sdk.doc.stats() return {} end
+sdk.knowledge = {}
+function sdk.knowledge.search(query, limit) return {} end
+function sdk.knowledge.add(tag, content) return nil end
+function sdk.knowledge.list() return {} end
+sdk.text_memory = {}
+function sdk.text_memory.append(evt) return nil end
+sdk.llm = {}
+function sdk.llm.list_sources() return {} end
+function sdk.llm.set_source(name) return nil end
+function sdk.llm.current_source() return nil end
+sdk.social = {}
+function sdk.social.get_person(name) return {} end
+function sdk.social.get_network(name, depth) return {} end
+function sdk.social.get_trait(name, trait) return {value=nil, found=false} end
+function sdk.social.get_relations(name) return {} end
+function sdk.social.list_persons() return {} end
+sdk.settings = {}
+function sdk.settings.get_core(key) return nil end
+function sdk.settings.set_core(key, value) return nil end
+function sdk.settings.list_core(prefix) return {} end
+function sdk.settings.get_plugin(plugin, key) return nil end
+function sdk.settings.set_plugin(plugin, key, value) return nil end
+function sdk.settings.list_plugin(plugin, prefix) return {} end
+function sdk.settings.list(prefix) return {} end
+function sdk.settings.register_def(def) return nil end
+function sdk.settings.defs(prefix) return {} end
+function sdk.settings.dump() return {} end
+function sdk.settings.plugins() return {} end
+sdk.json = {}
+function sdk.json.encode(val)
+    if type(val) == "string" then return '"' .. val:gsub('"', '\\"'):gsub('\n', '\\n') .. '"'
+    elseif type(val) == "number" or type(val) == "boolean" then return tostring(val)
+    elseif type(val) == "table" then local parts, i = {}, 1
+        for k, v in pairs(val) do parts[i] = sdk.json.encode(k) .. ":" .. sdk.json.encode(v); i = i + 1 end
+        return "{" .. table.concat(parts, ",") .. "}" end
+    return "null"
+end
+function sdk.json.decode(str) local ok, fn = pcall(load, "return " .. str); if ok then return fn() end; return nil end
+sdk.http = {}
+function sdk.http.get(url) print("[lua-plugin] http.get: " .. tostring(url)); return {status=200, body='{"mock":true}', headers={}} end
+function sdk.http.post(url, body, ct) print("[lua-plugin] http.post: " .. tostring(url)); return {status=200, body='{"mock":true}', headers={}} end
+return sdk
+`
+
+const tmplMainLua = `-- {{.Plg.Name}} plugin
+local plugin = { name = "{{.Plg.Name}}" }
+function plugin.start(sdk)
+  sdk.log("info", "{{.Plg.Name}} starting...")
+  sdk.register_tool("{{.Plg.Name}}_hello", {
+    description = "A hello world tool",
+    parameters = { type = "object", properties = {} }
+  }, function(args) return { content = "Hello from {{.Plg.Name}} plugin!" } end)
+  sdk.log("info", "{{.Plg.Name}} started")
+end
+function plugin.stop() sdk.log("info", "{{.Plg.Name}} stopped") end
+return plugin
+`
+
+// ============================================================
+// Remote Device Adapter Templates
+// ============================================================
+
+const tmplRemoteDeviceMain = `#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "ha_remotedevice.h"
+
+/* ============================================================
+ *  {{.Plg.Name}} — Remote Device Adapter
+ *
+ *  声明式远程设备接入示例。
+ *  用户只需实现：
+ *    1. ha_transport_t 的 4 个函数
+ *    2. 声明 handlers 表（设备支持哪些命令 + 对应的处理函数）
+ *  其余协议细节（WS 握手、hello/bind、心跳、重连、命令分发、结果回执）由 SDK 自动处理。
+ * ============================================================ */
+
+/* ====================== 传输层实现 ======================
+ *
+ * 请为你的平台实现以下 4 个函数：
+ *   connect(ctx, host, port) — 建立 TCP 连接
+ *   send(ctx, data, len)     — 发送数据
+ *   recv(ctx, buf, len)      — 接收数据（阻塞，返回实际接收字节数）
+ *   close(ctx)               — 关闭连接
+ *
+ * 示例：POSIX socket 实现
+ */
+
+#if defined(_WIN32) || defined(_WIN64)
+/* Windows 平台需包含 winsock2.h */
+#error "Please implement transport for your platform (see example below)"
+#else
+/* POSIX (Linux, macOS, ESP-IDF, Zephyr, etc.) */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+
+struct transport_ctx {
+    int sock;
+};
+
+static int transport_connect(void *ctx, const char *host, uint16_t port) {
+    struct transport_ctx *tc = (struct transport_ctx *)ctx;
+    struct hostent *he = gethostbyname(host);
+    if (!he) return -1;
+    tc->sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (tc->sock < 0) return -1;
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    memcpy(&addr.sin_addr, he->h_addr_list[0], he->h_length);
+    if (connect(tc->sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        close(tc->sock);
+        tc->sock = -1;
+        return -1;
+    }
+    return 0;
+}
+
+static int transport_send(void *ctx, const uint8_t *data, int len) {
+    struct transport_ctx *tc = (struct transport_ctx *)ctx;
+    int sent = 0;
+    while (sent < len) {
+        int n = (int)send(tc->sock, data + sent, len - sent, 0);
+        if (n <= 0) return -1;
+        sent += n;
+    }
+    return sent;
+}
+
+static int transport_recv(void *ctx, uint8_t *buf, int len) {
+    struct transport_ctx *tc = (struct transport_ctx *)ctx;
+    int n = (int)recv(tc->sock, buf, len, 0);
+    return n;
+}
+
+static void transport_close(void *ctx) {
+    struct transport_ctx *tc = (struct transport_ctx *)ctx;
+    if (tc->sock >= 0) {
+        close(tc->sock);
+        tc->sock = -1;
+    }
+}
+#endif
+
+/* ====================== 声明式命令处理 ======================
+ *
+ * 每个命令对应一个处理函数，通过填写 ha_cmd_result_t 返回数据。
+ * SDK 自动回执结果，无需手动调用 send_result。
+ *
+ * 返回方式：
+ *   1. 文本输出：填写 result->output
+ *   2. 二进制数据：设置 result->has_binary=1 并填写 binary_data/len/mime
+ *   3. 错误：设置 result->status=1 并填写 result->error
+ *   4. 返回 HA_OK 表示处理成功，其他值表示处理失败
+ */
+
+/* ESP32-CAM 摄像头处理 */
+static ha_status_t handle_camerasue(const char *req_id, const char *args,
+                                    ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    int duration = 0;
+    if (args && args[0]) duration = atoi(args);
+    printf("[camera] %s (duration=%ds)\n", duration ? "record" : "snapshot", duration);
+
+    /* 返回文本结果（base64 图片） */
+    result->status = 0;
+    result->output = "data:image/jpeg;base64,/9j/4AAQ...";
+    return HA_OK;
+}
+
+/* 屏幕截图处理 */
+static ha_status_t handle_screensee(const char *req_id, const char *args,
+                                    ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)args; (void)userdata;
+    printf("[screen] screenshot\n");
+    result->status = 0;
+    result->output = "data:image/png;base64,iVBORw0KGgo...";
+    return HA_OK;
+}
+
+/* 语音播报处理 */
+static ha_status_t handle_speakeruse(const char *req_id, const char *args,
+                                     ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    printf("[speaker] TTS: %s\n", args ? args : "");
+    result->status = 0;
+    result->output = "speakeruse done";
+    return HA_OK;
+}
+
+/* 远程操控处理（computeruse） */
+static ha_status_t handle_computeruse(const char *req_id, const char *args,
+                                      ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    const char *action = NULL;
+    const char *json_str = NULL;
+    ha_cmd_parse_json(args, &action, &json_str);
+    printf("[computeruse] action=%s\n", action ? action : "unknown");
+    result->status = 0;
+    result->output = "computeruse done";
+    return HA_OK;
+}
+
+/* 剪贴板读取 */
+static ha_status_t handle_clipboardsee(const char *req_id, const char *args,
+                                       ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)args; (void)userdata;
+    result->status = 0;
+    result->output = "clipboard content";
+    return HA_OK;
+}
+
+/* 剪贴板写入 */
+static ha_status_t handle_clipboardsue(const char *req_id, const char *args,
+                                       ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    printf("[clipboard] write: %s\n", args ? args : "");
+    result->status = 0;
+    result->output = "clipboard written";
+    return HA_OK;
+}
+
+/* 屏幕显示 */
+static ha_status_t handle_screensue(const char *req_id, const char *args,
+                                    ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    printf("[screensue] show: %s\n", args ? args : "");
+    result->status = 0;
+    result->output = "screensue shown";
+    return HA_OK;
+}
+
+/* Shell 命令处理 */
+static ha_status_t handle_shell(const char *req_id, const char *args,
+                                ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)userdata;
+    printf("[shell] cmd: %s\n", args ? args : "");
+    result->status = 0;
+    result->output = "shell output";
+    return HA_OK;
+}
+
+/* 设备信息查询 */
+static ha_status_t handle_deviceinfo(const char *req_id, const char *args,
+                                     ha_cmd_result_t *result, void *userdata) {
+    (void)req_id; (void)args; (void)userdata;
+    result->status = 0;
+    result->output = "{\"platform\":\"linux\",\"arch\":\"x86_64\"}";
+    return HA_OK;
+}
+
+/* ====================== 连接状态回调 ====================== */
+
+static void on_state(int connected, void *userdata) {
+    (void)userdata;
+    printf("[devicelink] state: %s\n", connected ? "connected" : "disconnected");
+}
+
+/* ====================== 主函数 ====================== */
+
+int main(int argc, char *argv[]) {
+    /* 传输层上下文 */
+    struct transport_ctx tctx;
+    tctx.sock = -1;
+
+    ha_transport_t transport = {
+        .connect = transport_connect,
+        .send    = transport_send,
+        .recv    = transport_recv,
+        .close   = transport_close,
+        .ctx     = &tctx,
+    };
+
+    /* ===== 声明式设备配置 ===== */
+
+    /* 声明设备能力 */
+    const char *caps[] = {
+        "status", "cmdrun", "deviceinfo",
+        "camerasue", "screensee", "speakeruse",
+        "computeruse", "clipboardsee", "clipboardsue",
+        "screensue",
+        NULL
+    };
+
+    /* 声明命令处理表：设备支持哪些命令，以及对应的处理函数 */
+    ha_cmd_handler_def_t handlers[] = {
+        {.command = "shell",        .handler = handle_shell},
+        {.command = "camerasue",    .handler = handle_camerasue},
+        {.command = "screensee",    .handler = handle_screensee},
+        {.command = "speakeruse",   .handler = handle_speakeruse},
+        {.command = "computeruse",  .handler = handle_computeruse},
+        {.command = "clipboardsee", .handler = handle_clipboardsee},
+        {.command = "clipboardsue", .handler = handle_clipboardsue},
+        {.command = "screensue",    .handler = handle_screensue},
+        {.command = "deviceinfo",   .handler = handle_deviceinfo},
+        {.command = NULL},  /* 标记结束 */
+    };
+
+    ha_config_t config = {
+        .transport = transport,
+        .server    = "127.0.0.1:9890",
+        .token     = "your-token-here",
+        .device = {
+            .device_id = "{{.Plg.Name}}",
+            .name      = "{{.Plg.NameEn}}",
+            .kind      = "computer",
+            .caps      = caps,
+            .info_json = "{\"platform\":\"linux\",\"arch\":\"x86_64\"}",
+        },
+        .handlers  = handlers,   /* 声明式命令处理表 */
+        .on_state  = on_state,
+        .ping_interval = 30,
+    };
+
+    ha_client_t *client = ha_client_new(&config);
+    if (!client) {
+        fprintf(stderr, "Failed to create client\n");
+        return 1;
+    }
+
+    printf("Starting remote device adapter: {{.Plg.Name}}\n");
+    printf("  Server: %s\n", config.server);
+    printf("  Device ID: %s\n", config.device.device_id);
+    printf("  Kind: %s\n", config.device.kind);
+    printf("  Caps: ");
+    for (const char **p = caps; *p; p++) printf("%s ", *p);
+    printf("\n");
+
+    ha_status_t st = ha_client_start(client);
+    if (st != HA_OK) {
+        fprintf(stderr, "Failed to connect: %d\n", st);
+        ha_client_destroy(client);
+        return 1;
+    }
+
+    printf("Connected! Entering main loop...\n");
+
+    /* 主循环 */
+    while (1) {
+        ha_status_t st = ha_client_process(client);
+        if (st == HA_ERR_DISCONNECTED) {
+            printf("Disconnected, exiting.\n");
+            break;
+        }
+#if defined(_WIN32) || defined(_WIN64)
+        Sleep(10);
+#else
+        usleep(10000);
+#endif
+    }
+
+    ha_client_stop(client);
+    ha_client_destroy(client);
+    return 0;
+}
+`
+
+const tmplRemoteDeviceCMake = `cmake_minimum_required(VERSION 3.10)
+project({{.Plg.Name}} VERSION 0.1.0 LANGUAGES C)
+
+# ============================================================
+# {{.Plg.Name}} — Remote Device Adapter
+# ============================================================
+
+# 设置 SDK 路径（默认使用内置 SDK，也可通过 -DSDK_PATH=... 指定）
+set(SDK_PATH "${CMAKE_CURRENT_SOURCE_DIR}/ha_remotedevice"
+    CACHE PATH "Path to ha_remotedevice SDK")
+
+# 添加 SDK 子目录
+if(EXISTS "${SDK_PATH}/CMakeLists.txt")
+    add_subdirectory(${SDK_PATH} ha_remotedevice)
+else()
+    message(FATAL_ERROR "ha_remotedevice SDK not found at ${SDK_PATH}")
+endif()
+
+# 创建设备适配器可执行文件
+add_executable(${PROJECT_NAME}
+    main.c
+)
+
+# 链接 SDK
+target_link_libraries(${PROJECT_NAME} PRIVATE ha_remotedevice)
+
+# 包含 SDK 头文件
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${HA_REMOTEDEVICE_INCLUDE_DIR}
+)
+
+# 编译选项
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+    target_compile_options(${PROJECT_NAME} PRIVATE
+        -Wall -Wextra -Wpedantic
+        -Wno-unused-parameter
+    )
+endif()
+
+# 安装
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
+`
+
+const tmplReadme = `# {{.Plg.Name}}
+
+{{.Plg.Description}}
+
+## Build
+
+` + "```bash" + `
+hmapdev build
+` + "```" + `
+
+## Install
+
+Upload the .hmap file through the Plugin Manager API.
+`

tools/hmapdev/templates/proc_shm_unix.go.tmpl

@@ -0,0 +1,54 @@
+//go:build linux || darwin || freebsd
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+)
+
+// Unix 侧共享段挂载：内核经 ExtraFiles 传入继承的 fd。
+//
+// 统一共享内存区域布局（§13.1）：
+//
+//	fd 3 = 统一区域（SuperBlock + StageContext + EvtRing）
+//	fd 4 = 事件通知（Linux eventfd / macOS pipe 读端）
+//
+// 继承的 fd 无需文件名，也不残留——这是选 memfd 而非 /dev/shm 的原因。
+const (
+	fdUnifiedShm  = 3
+	fdEvtNotifier = 4
+)
+
+// attachUnifiedShm 挂载统一共享内存区域。
+//
+// 各进程 mmap 到不同虚拟地址，段内一律用相对偏移而非指针，故仍能正确解引用
+// （实验 2 已验证父子 mmap 基址不同时偏移解引用正确）。
+func attachUnifiedShm(size int) ([]byte, error) {
+	return syscall.Mmap(fdUnifiedShm, 0, size,
+		syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
+}
+
+// openEvtNotifier 打开事件通知读端。
+func openEvtNotifier() (evtWaiter, error) {
+	f := os.NewFile(fdEvtNotifier, "evtnotify")
+	if f == nil {
+		return nil, fmt.Errorf("fd %d 不是有效的通知句柄", fdEvtNotifier)
+	}
+	return &unixEvtWaiter{f: f}, nil
+}
+
+// unixEvtWaiter 用 eventfd/pipe 的阻塞 Read 等待通知。
+//
+// os.NewFile 把 fd 注册进 runtime netpoller，Read 阻塞时只 park goroutine，
+// 不占 OS 线程（实验 1：200 个等待者仅增 1 个 OS 线程）。
+// 反面对照是经 cgo 调 sem_wait——那会阻塞整个 M。
+type unixEvtWaiter struct {
+	f *os.File
+}
+
+func (w *unixEvtWaiter) Wait(buf []byte) error {
+	_, err := w.f.Read(buf)
+	return err
+}

tools/hmapdev/templates/proc_shm_windows.go.tmpl

@@ -0,0 +1,153 @@
+//go:build windows
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+// Windows 侧共享段挂载：走命名对象而非继承 fd。
+//
+// 为何不能照抄 Unix：Windows 没有 fd 继承语义，`ExtraFiles` 在 os/exec 的
+// Windows 实现里不被支持。等价机制是命名内核对象——父进程用
+// CreateFileMapping / CreateEvent 建带名字的对象，子进程按同名 Open 拿到同一对象。
+//
+// 名字经环境变量传入（内核 internal/plugin/proc/plugin_windows.go 设置），
+// 而不是硬编码：多个 homed 实例并存时不能撞名。
+//
+// **这是 §9.2 的正解**：C ABI 时代 Windows 是第三套独立 ABI 实现，
+// stage 只下发 3 个字段且完全没有写回，sanitizer 这类改写型插件静默失效。
+// 现在 Windows 与 Unix 共用同一份 RPC 逻辑与同一份共享段布局，
+// 差异被收敛到本文件的三个函数里。
+const (
+	envStageShmName = "HOMEAGENT_SHM_STAGE"
+	envEvtRingName  = "HOMEAGENT_SHM_EVTRING"
+	envEvtEventName = "HOMEAGENT_EVT_EVENT"
+)
+
+// Windows API 绑定：用 LazyDLL 而非 golang.org/x/sys/windows。
+//
+// 原因：OpenFileMappingW / OpenEventW 未被标准库 syscall 包导出。
+// 引入 x/sys 会给**每个插件的 go.mod 加一个新依赖**，
+// 而「外部插件零改动」是本次迁移的硬约束（插件仅依赖公开 SDK）。
+// LazyDLL 属于标准库 syscall，零新增依赖。
+var (
+	kernel32             = syscall.NewLazyDLL("kernel32.dll")
+	procOpenFileMappingW = kernel32.NewProc("OpenFileMappingW")
+	procOpenEventW       = kernel32.NewProc("OpenEventW")
+)
+
+const (
+	winEventModifyState = 0x0002
+	winSynchronize      = 0x00100000
+)
+
+// openFileMappingW 封装 OpenFileMappingW。
+func openFileMappingW(access uint32, inherit bool, name *uint16) (syscall.Handle, error) {
+	var inheritFlag uintptr
+	if inherit {
+		inheritFlag = 1
+	}
+	r, _, err := procOpenFileMappingW.Call(
+		uintptr(access), inheritFlag, uintptr(unsafe.Pointer(name)))
+	if r == 0 {
+		return 0, err
+	}
+	return syscall.Handle(r), nil
+}
+
+// openEventW 封装 OpenEventW。
+func openEventW(access uint32, inherit bool, name *uint16) (syscall.Handle, error) {
+	var inheritFlag uintptr
+	if inherit {
+		inheritFlag = 1
+	}
+	r, _, err := procOpenEventW.Call(
+		uintptr(access), inheritFlag, uintptr(unsafe.Pointer(name)))
+	if r == 0 {
+		return 0, err
+	}
+	return syscall.Handle(r), nil
+}
+
+// attachStageShm 按名字打开 StageContext 段并映射。
+func attachStageShm(size int) ([]byte, error) {
+	return openNamedMapping(os.Getenv(envStageShmName), size, "StageContext 段")
+}
+
+// attachEvtRingShm 按名字打开事件环段并映射。
+func attachEvtRingShm(size int) ([]byte, error) {
+	return openNamedMapping(os.Getenv(envEvtRingName), size, "事件环段")
+}
+
+// openNamedMapping 打开命名共享段并映射为 []byte。
+//
+// 与 Unix 的 mmap 语义对齐：MapViewOfFile 返回的地址在本进程虚拟空间，
+// 段内偏移仍是相对的，故跨进程解引用正确。
+func openNamedMapping(name string, size int, what string) ([]byte, error) {
+	if name == "" {
+		return nil, fmt.Errorf("%s 名字未经环境变量传入", what)
+	}
+	namePtr, err := syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return nil, fmt.Errorf("%s 名字非法: %w", what, err)
+	}
+
+	h, err := openFileMappingW(syscall.FILE_MAP_WRITE, false, namePtr)
+	if err != nil {
+		return nil, fmt.Errorf("打开 %s（%s）: %w", what, name, err)
+	}
+
+	addr, err := syscall.MapViewOfFile(h, syscall.FILE_MAP_WRITE, 0, 0, uintptr(size))
+	if err != nil {
+		syscall.CloseHandle(h)
+		return nil, fmt.Errorf("映射 %s: %w", what, err)
+	}
+	// 句柄不关：视图存活期间必须保持句柄有效，进程退出时由 OS 回收。
+
+	return unsafe.Slice((*byte)(unsafe.Pointer(addr)), size), nil
+}
+
+// openEvtNotifier 按名字打开事件通知对象。
+func openEvtNotifier() (evtWaiter, error) {
+	name := os.Getenv(envEvtEventName)
+	if name == "" {
+		return nil, fmt.Errorf("事件通知对象名字未经环境变量传入")
+	}
+	namePtr, err := syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return nil, fmt.Errorf("事件对象名字非法: %w", err)
+	}
+	h, err := openEventW(winSynchronize|winEventModifyState, false, namePtr)
+	if err != nil {
+		return nil, fmt.Errorf("打开事件对象（%s）: %w", name, err)
+	}
+	return &windowsEvtWaiter{h: h}, nil
+}
+
+// windowsEvtWaiter 用命名 Event 对象等待通知。
+//
+// 与 eventfd 的差异：Event 是二元信号而非计数器，多次 SetEvent 只对应
+// 一次唤醒。这不影响正确性——消费者被唤醒后按 readSeq 追 writeSeq
+// 批量 drain，一次唤醒能处理累积的全部事件。
+//
+// WaitForSingleObject 阻塞的是 OS 线程而非仅 goroutine，故不如 eventfd
+// 的 netpoller 路径省线程。每插件一个消费 goroutine，17 插件即 17 线程，
+// 在可接受范围（实验 5 实测 17 子进程共 84 线程）。
+type windowsEvtWaiter struct {
+	h syscall.Handle
+}
+
+func (w *windowsEvtWaiter) Wait(buf []byte) error {
+	ev, err := syscall.WaitForSingleObject(w.h, syscall.INFINITE)
+	if err != nil {
+		return err
+	}
+	if ev != syscall.WAIT_OBJECT_0 {
+		return fmt.Errorf("等待事件对象返回 0x%x", ev)
+	}
+	return nil
+}

tools/hmapdev/yaegi/interp.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/traefik/yaegi/interp"
 	"github.com/traefik/yaegi/stdlib"
-	"github.com/JianFeeeee/homeagent-sdk/tools/plugindev/yaegi/mocksdk"
+	"gitcode.com/JianFeeeee/homeagent-sdk/tools/hmapdev/yaegi/mocksdk"
 )
 
 type YaegiDebugger struct {

tools/hmapdev/yaegi/mocksdk/plugin.go

@@ -83,18 +83,69 @@ type ToolResult struct {
 }
 
 type ToolDef struct {
-	Name        string                 `json:"name"`
-	Plugin      string                 `json:"plugin,omitempty"`
-	Description string                 `json:"description"`
-	Parameters  map[string]interface{} `json:"parameters"`
-	NoMemory    bool                   `json:"no_memory,omitempty"`
-	Cleaner     func(string) string    `json:"-"`
+	Name          string                 `json:"name"`
+	Plugin        string                 `json:"plugin,omitempty"`
+	Description   string                 `json:"description"`
+	Parameters    map[string]interface{} `json:"parameters"`
+	NoMemory      bool                   `json:"no_memory,omitempty"`
+	Cleaner       func(string) string    `json:"-"`
+	ContextPolicy string                 `json:"context_policy,omitempty"`
+}
+
+// 上下文策略取值，与公共 SDK 一致。
+const (
+	ContextPolicyNone  = "none"
+	ContextPolicyPrune = "prune"
+)
+
+// InjectOptions 与公共 SDK 同构：声明一次注入是否记入记忆、是否据此裁剪上下文、
+// 以及用哪个已注册的通道 cleaner 清洗注入内容。
+type InjectOptions struct {
+	NoMemory      bool
+	ContextPolicy string
+	CleanerName   string
 }
 
 type IOInjector interface {
 	InjectInterruptText(source, channel, text string)
 	InjectText(source, channel, text string)
 	InjectTextNoMemory(source, channel, text string)
+	// InjectInputSync 注入输入事件并同步等待 agent 回复（无回复时返回空串）。
+	// 通道类插件（qq / a2a 等）靠它完成「收到入站 → agent 处理 → 回复取回」闭环，
+	// 而 mock 此前只有带 flags 的 InjectInputSyncOpts、没有这个零值糖——
+	// 于是一个能在 plugin.bin 里编译通过、在 yaegi 下却调不通的方法就长住了。
+	InjectInputSync(source, channel, text string) string
+	// 1.1.0 媒体注入。与公共 SDK 同构：插件在 yaegi 下调得通的方法，
+	// 编成 plugin.bin 后必须也调得通，否则调试期与真实运行行为不一致。
+	InjectInputMedia(source, channel, text string, blocks []ContentBlock)
+	InjectInputMediaSync(source, channel, text string, blocks []ContentBlock) string
+	InjectInterruptMedia(source, channel, text string, blocks []ContentBlock)
+	SetToolBlocks(blocks []ContentBlock)
+
+	// 1.2.0 带标志位的注入，与公共 SDK 同构。
+	InjectTextOpts(source, channel, text string, opts InjectOptions)
+	InjectInterruptTextOpts(source, channel, text string, opts InjectOptions)
+	InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string
+	InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+	InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string
+	InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions)
+}
+
+// ContentBlock 与公共 SDK 同构（OpenAI 多模态内容块格式）。
+type ContentBlock struct {
+	Type     string    `json:"type"`
+	Text     string    `json:"text,omitempty"`
+	ImageURL *ImageURL `json:"image_url,omitempty"`
+	AudioURL *AudioURL `json:"audio_url,omitempty"`
+}
+
+type ImageURL struct {
+	URL    string `json:"url"`
+	Detail string `json:"detail,omitempty"`
+}
+
+type AudioURL struct {
+	URL string `json:"url"`
 }
 
 type EventType string
@@ -159,29 +210,33 @@ type mockSettings struct{ data map[string]interface{} }
 
 func (s *mockSettings) Get(key string) (interface{}, error) {
 	v, ok := s.data[key]
-	if !ok { return nil, nil }
+	if !ok {
+		return nil, nil
+	}
 	return v, nil
 }
 func (s *mockSettings) Set(key string, value interface{}) error { s.data[key] = value; return nil }
 func (s *mockSettings) List(prefix string) ([]string, error) {
 	var ks []string
 	for k := range s.data {
-		if strings.HasPrefix(k, prefix) { ks = append(ks, k) }
+		if strings.HasPrefix(k, prefix) {
+			ks = append(ks, k)
+		}
 	}
 	return ks, nil
 }
-func (s *mockSettings) GetCore(key string) (interface{}, error) { return nil, nil }
-func (s *mockSettings) SetCore(key string, value interface{}) error { return nil }
-func (s *mockSettings) ListCore(prefix string) ([]string, error) { return nil, nil }
-func (s *mockSettings) GetPlugin(p, k string) (interface{}, error) { return nil, nil }
-func (s *mockSettings) SetPlugin(p, k string, v interface{}) error { return nil }
+func (s *mockSettings) GetCore(key string) (interface{}, error)       { return nil, nil }
+func (s *mockSettings) SetCore(key string, value interface{}) error   { return nil }
+func (s *mockSettings) ListCore(prefix string) ([]string, error)      { return nil, nil }
+func (s *mockSettings) GetPlugin(p, k string) (interface{}, error)    { return nil, nil }
+func (s *mockSettings) SetPlugin(p, k string, v interface{}) error    { return nil }
 func (s *mockSettings) ListPlugin(p, prefix string) ([]string, error) { return nil, nil }
 func (s *mockSettings) RegisterDef(def ConfigDef) {
 	logf("config def: %s = %s", def.Key, def.Default)
 }
 func (s *mockSettings) Defs(prefix string) []*ConfigDef { return nil }
-func (s *mockSettings) Dump() map[string]interface{} { return s.data }
-func (s *mockSettings) Plugins() []string { return nil }
+func (s *mockSettings) Dump() map[string]interface{}    { return s.data }
+func (s *mockSettings) Plugins() []string               { return nil }
 
 type Entity struct {
 	Name       string            `json:"name"`
@@ -195,10 +250,21 @@ type Relation struct {
 	Object    string `json:"object"`
 }
 
+// Triple 与公共 SDK 同构。
+//
+// ❗字段名曾是 `Predicate`，而公共 SDK 一直叫 `Relation`。
+// yaegi 解释器下插件写 `Relation:` 会报未知字段，写 `Predicate:` 则在
+// 编成 plugin.bin 时报错——谁都不对。没人发现是因为没有任何代码
+// 对着 mocksdk 编译，漂移不会被编译器抓到。
 type Triple struct {
-	Subject   string `json:"subject"`
-	Predicate string `json:"predicate"`
-	Object    string `json:"object"`
+	Subject      string   `json:"subject"`
+	Relation     string   `json:"relation"`
+	Object       string   `json:"object"`
+	Confidence   float64  `json:"confidence,omitempty"`
+	SubjectType  string   `json:"subject_type,omitempty"`
+	ObjectType   string   `json:"object_type,omitempty"`
+	SentenceText string   `json:"sentence_text,omitempty"`
+	MediaDigests []string `json:"media_digests,omitempty"`
 }
 
 type MemoryAPI interface {
@@ -212,37 +278,57 @@ type MemoryAPI interface {
 type mockMemory struct{}
 
 func (mockMemory) Recall(q []string, d int) ([]Entity, []Relation, error) { return nil, nil, nil }
-func (mockMemory) Commit(t []Triple) error                                  { return nil }
-func (mockMemory) Introspect() (map[string]interface{}, error)              { return map[string]interface{}{}, nil }
-func (mockMemory) MergeEntities(s, t string) (int, error)                   { return 0, nil }
-func (mockMemory) Purge(c map[string]string, m string) (int, error)         { return 0, nil }
+func (mockMemory) Commit(t []Triple) error                                { return nil }
+func (mockMemory) Introspect() (map[string]interface{}, error)            { return map[string]interface{}{}, nil }
+func (mockMemory) MergeEntities(s, t string) (int, error)                 { return 0, nil }
+func (mockMemory) Purge(c map[string]string, m string) (int, error)       { return 0, nil }
 
 type Doc struct {
 	ID      string `json:"id"`
 	Title   string `json:"title"`
 	Content string `json:"content"`
 	Source  string `json:"source"`
+	// 1.1.0：媒体字段。与公共 SDK 保持同构，否则插件在 yaegi 下跑得通、
+	// 编成 plugin.bin 却编不过（或反之）。
+	MediaDigests []string          `json:"media_digests,omitempty"`
+	Attachments  []MediaAttachment `json:"attachments,omitempty"`
+}
+
+// MediaAttachment 与公共 SDK 同构：写入时给 Data+MIME，引用已有内容时只给 Digest。
+type MediaAttachment struct {
+	Digest      string `json:"digest,omitempty"`
+	MIME        string `json:"mime,omitempty"`
+	Data        []byte `json:"data,omitempty"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
 }
 
 type DocMemoryAPI interface {
 	Query(text string, topK int) []*Doc
 	Insert(doc *Doc) error
+	InsertWithMedia(doc *Doc, attachments []MediaAttachment) error
 	Remove(id string)
 	Stats() map[string]interface{}
 }
 
 type mockDocMemory struct{}
 
-func (mockDocMemory) Query(t string, k int) []*Doc       { return nil }
-func (mockDocMemory) Insert(doc *Doc) error               { return nil }
-func (mockDocMemory) Remove(id string)                    {}
-func (mockDocMemory) Stats() map[string]interface{}       { return nil }
+func (mockDocMemory) Query(t string, k int) []*Doc { return nil }
+func (mockDocMemory) Insert(doc *Doc) error        { return nil }
+func (mockDocMemory) InsertWithMedia(doc *Doc, atts []MediaAttachment) error {
+	logf("doc_insert_with_media: %d 份附件", len(atts))
+	return nil
+}
+func (mockDocMemory) Remove(id string)              {}
+func (mockDocMemory) Stats() map[string]interface{} { return nil }
 
 type TextEvent struct {
 	Timestamp int64  `json:"timestamp"`
 	Role      string `json:"role"`
 	Content   string `json:"content"`
 	Source    string `json:"source"`
+	// 1.1.0：附件。读回时内核从正文标记反解，写入时内核把标记并进正文。
+	Attachments []MediaAttachment `json:"attachments,omitempty"`
 }
 
 type TextMemoryAPI interface {
@@ -305,8 +391,8 @@ type LLMAPI interface {
 type mockLLM struct{}
 
 func (mockLLM) ListSources() []string    { return nil }
-func (mockLLM) SetSource(n string) error  { return nil }
-func (mockLLM) CurrentSource() string     { return "" }
+func (mockLLM) SetSource(n string) error { return nil }
+func (mockLLM) CurrentSource() string    { return "" }
 
 type IOInjectorImpl struct{}
 
@@ -319,27 +405,68 @@ func (IOInjectorImpl) InjectText(source, channel, text string) {
 func (IOInjectorImpl) InjectTextNoMemory(source, channel, text string) {
 	logf("inject_text_no_memory: source=%s channel=%s", source, channel)
 }
+func (IOInjectorImpl) InjectInputMedia(source, channel, text string, blocks []ContentBlock) {
+	logf("inject_input_media: source=%s channel=%s blocks=%d", source, channel, len(blocks))
+}
+func (IOInjectorImpl) InjectInputMediaSync(source, channel, text string, blocks []ContentBlock) string {
+	logf("inject_input_media_sync: source=%s channel=%s blocks=%d", source, channel, len(blocks))
+	return ""
+}
+func (IOInjectorImpl) InjectInterruptMedia(source, channel, text string, blocks []ContentBlock) {
+	logf("inject_interrupt_media: source=%s channel=%s blocks=%d", source, channel, len(blocks))
+}
+func (IOInjectorImpl) SetToolBlocks(blocks []ContentBlock) {
+	logf("set_tool_blocks: blocks=%d", len(blocks))
+}
+
+// ---- 带 InjectOptions 的注入 ----
+
+func (IOInjectorImpl) InjectInputSync(source, channel, text string) string {
+	logf("inject_sync: source=%s channel=%s", source, channel)
+	return ""
+}
+
+func (IOInjectorImpl) InjectTextOpts(source, channel, text string, opts InjectOptions) {
+	logf("inject_text_opts: source=%s channel=%s no_memory=%v policy=%s", source, channel, opts.NoMemory, opts.ContextPolicy)
+}
+func (IOInjectorImpl) InjectInterruptTextOpts(source, channel, text string, opts InjectOptions) {
+	logf("inject_interrupt_opts: source=%s channel=%s no_memory=%v policy=%s", source, channel, opts.NoMemory, opts.ContextPolicy)
+}
+func (IOInjectorImpl) InjectInputSyncOpts(source, channel, text string, opts InjectOptions) string {
+	logf("inject_sync_opts: source=%s channel=%s no_memory=%v policy=%s", source, channel, opts.NoMemory, opts.ContextPolicy)
+	return ""
+}
+func (IOInjectorImpl) InjectInputMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) {
+	logf("inject_input_media_opts: source=%s channel=%s blocks=%d no_memory=%v policy=%s", source, channel, len(blocks), opts.NoMemory, opts.ContextPolicy)
+}
+func (IOInjectorImpl) InjectInputMediaSyncOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) string {
+	logf("inject_input_media_sync_opts: source=%s channel=%s blocks=%d no_memory=%v policy=%s", source, channel, len(blocks), opts.NoMemory, opts.ContextPolicy)
+	return ""
+}
+func (IOInjectorImpl) InjectInterruptMediaOpts(source, channel, text string, blocks []ContentBlock, opts InjectOptions) {
+	logf("inject_interrupt_media_opts: source=%s channel=%s blocks=%d no_memory=%v policy=%s", source, channel, len(blocks), opts.NoMemory, opts.ContextPolicy)
+}
 
 type PluginSDK struct {
-	Name        string
-	mu          sync.RWMutex
-	toolDefs    map[string]ToolDef
-	toolHandlers map[string]ToolHandler
+	Name          string
+	mu            sync.RWMutex
+	toolDefs      map[string]ToolDef
+	toolHandlers  map[string]ToolHandler
 	stageHandlers map[string]StageHandler
-	outChannels  map[string]ToolHandler
-	Settings     SettingsAPI
-	IO           IOInjector
+	outChannels   map[string]ToolHandler
+	Settings      SettingsAPI
+	IO            IOInjector
 }
 
 func New(name string) *PluginSDK {
 	return &PluginSDK{
-		Name:         name,
-		toolDefs:     make(map[string]ToolDef),
-		toolHandlers: make(map[string]ToolHandler),
+		Name:          name,
+		toolDefs:      make(map[string]ToolDef),
+		toolHandlers:  make(map[string]ToolHandler),
 		stageHandlers: make(map[string]StageHandler),
-		outChannels:  make(map[string]ToolHandler),
-		Settings:     &mockSettings{data: map[string]interface{}{}},
-		IO:           IOInjectorImpl{},
+		outChannels:   make(map[string]ToolHandler),
+		Settings:      &mockSettings{data: map[string]interface{}{}},
+		IO:            IOInjectorImpl{},
 	}
 }
 

tools/plugindev/templates.go

@@ -1,847 +0,0 @@
-package main
-
-// tmplPlgJSON is the plg.json template
-const tmplPlgJSON = `{
-  "name": "{{.Plg.Name}}",
-  "name_zh": "{{.Plg.NameZh}}",
-  "name_en": "{{.Plg.NameEn}}",
-  "version": "{{.Plg.Version}}",
-  "description": "{{.Plg.Description}}",
-  "author": "{{.Plg.Author}}",
-  "entry": "{{.Plg.Entry}}",
-  "tags": [{{range $i, $t := .Plg.Tags}}{{if $i}}, {{end}}"{{$t}}"{{end}}],
-  "targets": "{{.Plg.Targets}}"
-}
-`
-
-const tmplGoMod = `module {{.ModulePath}}
-
-go {{.GoVersion}}
-
-require {{.SDKModule}} {{.SDKVersion}}
-`
-
-const tmplPluginGo = `package main
-
-import (
-	"fmt"
-	"gitcode.com/JianFeeeee/homeagent-sdk/sdk"
-)
-
-type Plugin struct {
-	name string
-	sdk  *sdk.PluginSDK
-}
-
-func (p *Plugin) Name() string { return p.name }
-
-func (p *Plugin) Start(s *sdk.PluginSDK) error {
-	p.sdk = s
-	s.RegisterStopHandler(func() { fmt.Printf("[%s] stop handler running\n", p.name) })
-	s.Settings().RegisterDef(sdk.ConfigDef{
-		Key: "plugin.{{.Plg.Name}}.example", Default: "hello", Type: "string",
-		DisplayName: "示例配置", Description: "An example configuration key",
-		Category: "{{.Plg.Name}}",
-	})
-	tp := p.name + "_"
-	s.RegisterTool(tp+"hello", sdk.ToolDef{
-		Name:        tp + "hello",
-		Description: "A hello world tool",
-		Parameters:  map[string]interface{}{"type": "object", "properties": map[string]interface{}{}},
-		NoMemory:    false, // 工具输出对 LLM 注意力有信号价值时为 false，纯操作工具为 true
-		// Cleaner: func(output string) string {
-		//     // 工具输出参与向量化/jieba/蒸馏前，在此过滤噪音
-		//     return output
-		// },
-	}, p.handleHello)
-	fmt.Printf("[%s] started\n", p.name)
-	return nil
-}
-
-func (p *Plugin) Stop() error { fmt.Printf("[%s] stopped\n", p.name); return nil }
-
-func (p *Plugin) handleHello(args map[string]interface{}) (interface{}, error) {
-	return map[string]interface{}{"content": "Hello from {{.Plg.Name}} plugin!"}, nil
-}
-
-func NewPluginFactory(name string, config map[string]interface{}) (sdk.Plugin, error) {
-	return &Plugin{name: name}, nil
-}
-`
-
-const tmplSDKLua = `-- HomeAgent Lua Plugin SDK (standalone mock)
-sdk = {}
-function sdk.log(level, msg) print("[lua-plugin] " .. tostring(level) .. ": " .. tostring(msg)) end
-function sdk.register_tool(name, def, handler) print("[lua-plugin] register_tool: " .. tostring(name)) end
-function sdk.register_stage(stage, handler, scope) print("[lua-plugin] register_stage: " .. tostring(stage) .. " scope=" .. tostring(scope)) end
-function sdk.register_api(name) print("[lua-plugin] register_api: " .. tostring(name)) end
-function sdk.register_output_channel(name, caps, desc, def, handler) print("[lua-plugin] register_output_channel: " .. tostring(name)) end
-function sdk.register_input_channel(name, def) print("[lua-plugin] register_input_channel: " .. tostring(name)) end
-function sdk.get_setting(key) return nil end
-function sdk.set_setting(key, value) print("[lua-plugin] set_setting: " .. tostring(key)) end
-function sdk.inject_text(source, channel, text) print("[lua-plugin] inject_text: " .. tostring(source)) end
-function sdk.inject_interrupt(source, channel, text) print("[lua-plugin] inject_interrupt: " .. tostring(source)) end
-function sdk.inject_text_no_memory(source, channel, text) print("[lua-plugin] inject_text_no_memory: " .. tostring(source)) end
-function sdk.set_auto_restart(enabled) print("[lua-plugin] set_auto_restart: " .. tostring(enabled)) end
-sdk.memory = {}
-function sdk.memory.recall(query, depth) return {entities={}, relations={}} end
-function sdk.memory.commit(triples) return nil end
-function sdk.memory.introspect() return {} end
-function sdk.memory.merge(source, target) return 0 end
-function sdk.memory.purge(criteria, hard) return 0 end
-sdk.doc = {}
-function sdk.doc.query(text, top_k) return {} end
-function sdk.doc.insert(doc) return nil end
-function sdk.doc.remove(id) return nil end
-function sdk.doc.stats() return {} end
-sdk.knowledge = {}
-function sdk.knowledge.search(query, limit) return {} end
-function sdk.knowledge.add(tag, content) return nil end
-function sdk.knowledge.list() return {} end
-sdk.text_memory = {}
-function sdk.text_memory.append(evt) return nil end
-sdk.llm = {}
-function sdk.llm.list_sources() return {} end
-function sdk.llm.set_source(name) return nil end
-function sdk.llm.current_source() return nil end
-sdk.social = {}
-function sdk.social.get_person(name) return {} end
-function sdk.social.get_network(name, depth) return {} end
-function sdk.social.get_trait(name, trait) return {value=nil, found=false} end
-function sdk.social.get_relations(name) return {} end
-function sdk.social.list_persons() return {} end
-sdk.settings = {}
-function sdk.settings.get_core(key) return nil end
-function sdk.settings.set_core(key, value) return nil end
-function sdk.settings.list_core(prefix) return {} end
-function sdk.settings.get_plugin(plugin, key) return nil end
-function sdk.settings.set_plugin(plugin, key, value) return nil end
-function sdk.settings.list_plugin(plugin, prefix) return {} end
-function sdk.settings.list(prefix) return {} end
-function sdk.settings.register_def(def) return nil end
-function sdk.settings.defs(prefix) return {} end
-function sdk.settings.dump() return {} end
-function sdk.settings.plugins() return {} end
-sdk.json = {}
-function sdk.json.encode(val)
-    if type(val) == "string" then return '"' .. val:gsub('"', '\\"'):gsub('\n', '\\n') .. '"'
-    elseif type(val) == "number" or type(val) == "boolean" then return tostring(val)
-    elseif type(val) == "table" then local parts, i = {}, 1
-        for k, v in pairs(val) do parts[i] = sdk.json.encode(k) .. ":" .. sdk.json.encode(v); i = i + 1 end
-        return "{" .. table.concat(parts, ",") .. "}" end
-    return "null"
-end
-function sdk.json.decode(str) local ok, fn = pcall(load, "return " .. str); if ok then return fn() end; return nil end
-sdk.http = {}
-function sdk.http.get(url) print("[lua-plugin] http.get: " .. tostring(url)); return {status=200, body='{"mock":true}', headers={}} end
-function sdk.http.post(url, body, ct) print("[lua-plugin] http.post: " .. tostring(url)); return {status=200, body='{"mock":true}', headers={}} end
-return sdk
-`
-
-const tmplMainLua = `-- {{.Plg.Name}} plugin
-local plugin = { name = "{{.Plg.Name}}" }
-function plugin.start(sdk)
-  sdk.log("info", "{{.Plg.Name}} starting...")
-  sdk.register_tool("{{.Plg.Name}}_hello", {
-    description = "A hello world tool",
-    parameters = { type = "object", properties = {} }
-  }, function(args) return { content = "Hello from {{.Plg.Name}} plugin!" } end)
-  sdk.log("info", "{{.Plg.Name}} started")
-end
-function plugin.stop() sdk.log("info", "{{.Plg.Name}} stopped") end
-return plugin
-`
-
-// tmplBridge — Windows DLL C ABI bridge (unchanged)
-const tmplBridge = `//go:build windows && cgo
-
-package main
-
-/*
-#include <stdlib.h>
-*/
-import "C"
-import (
-	"encoding/json"
-	"sync"
-	"unsafe"
-	sdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
-)
-
-var (
-	mu        sync.Mutex
-	handleMap = map[unsafe.Pointer]*bridgeState{}
-)
-
-type bridgeState struct {
-	plugin   sdk.Plugin
-	toolDefs map[string]sdk.ToolDef
-	handlers map[string]sdk.ToolHandler
-	stages   map[string]sdk.StageHandler
-	settings map[string]interface{}
-	sdk      *sdk.PluginSDK
-}
-
-func newHandle(plg sdk.Plugin) unsafe.Pointer {
-	mu.Lock(); defer mu.Unlock()
-	h := C.malloc(C.size_t(1))
-	handleMap[h] = &bridgeState{
-		plugin: plg, toolDefs: make(map[string]sdk.ToolDef),
-		handlers: make(map[string]sdk.ToolHandler), stages: make(map[string]sdk.StageHandler),
-		settings: make(map[string]interface{}),
-	}
-	return h
-}
-func getState(h unsafe.Pointer) *bridgeState { mu.Lock(); defer mu.Unlock(); return handleMap[h] }
-func delState(h unsafe.Pointer) { mu.Lock(); defer mu.Unlock(); delete(handleMap, h); C.free(h) }
-
-//export NewPlugin
-func NewPlugin(name *C.char, configJSON *C.char) unsafe.Pointer {
-	goName := C.GoString(name)
-	var config map[string]interface{}
-	if configJSON != nil {
-		var wrapper map[string]interface{}
-		if err := json.Unmarshal([]byte(C.GoString(configJSON)), &wrapper); err == nil {
-			if c, ok := wrapper["config"].(map[string]interface{}); ok { config = c }
-		}
-	}
-	plg, err := NewPluginFactory(goName, config)
-	if err != nil { return nil }
-	return newHandle(plg)
-}
-
-//export StartPlugin
-func StartPlugin(handle unsafe.Pointer) C.int {
-	bs := getState(handle)
-	if bs == nil { return 1 }
-	mockSett := &bridgeSettings{data: bs.settings}
-	mockSDK := sdk.New(bs.plugin.Name(), mockSett,
-		func(name string, def sdk.ToolDef, handler sdk.ToolHandler) error {
-			bs.toolDefs[name] = def; bs.handlers[name] = handler; return nil
-		},
-		func(stage sdk.Stage, handler sdk.StageHandler) { bs.stages[string(stage)] = handler },
-		func(name string) error { return nil },
-		func(name string, caps int, desc string, def sdk.ChannelDef, handler sdk.ToolHandler) error { return nil },
-	)
-	mockSDK.SetInputChannelRegistrar(func(name string, def sdk.ChannelDef) error { return nil })
-	bs.sdk = mockSDK
-	if err := bs.plugin.Start(mockSDK); err != nil { return 1 }
-	return 0
-}
-
-//export StopPlugin
-func StopPlugin(handle unsafe.Pointer) C.int {
-	bs := getState(handle)
-	if bs == nil { return 1 }
-	if bs.sdk != nil {
-		bs.sdk.RunStopHandlers()
-	}
-	if err := bs.plugin.Stop(); err != nil { return 1 }
-	return 0
-}
-
-//export DestroyPlugin
-func DestroyPlugin(handle unsafe.Pointer) {
-	if bs := getState(handle); bs != nil { delState(handle) }
-}
-
-//export GetToolDefsJSON
-func GetToolDefsJSON(handle unsafe.Pointer) *C.char {
-	bs := getState(handle)
-	if bs == nil { return nil }
-	defs := make([]sdk.ToolDef, 0, len(bs.toolDefs))
-	for _, def := range bs.toolDefs { defs = append(defs, def) }
-	b, _ := json.Marshal(defs)
-	return C.CString(string(b))
-}
-
-//export InvokeToolJSON
-func InvokeToolJSON(handle unsafe.Pointer, toolName *C.char, argsJSON *C.char) *C.char {
-	bs := getState(handle)
-	if bs == nil || toolName == nil { return nil }
-	goName := C.GoString(toolName)
-	handler, ok := bs.handlers[goName]
-	if !ok { errMsg, _ := json.Marshal(map[string]interface{}{"error": "tool not found: " + goName}); return C.CString(string(errMsg)) }
-	var args map[string]interface{}
-	if argsJSON != nil { json.Unmarshal([]byte(C.GoString(argsJSON)), &args) }
-	r, err := handler(args)
-	if err != nil { errMsg, _ := json.Marshal(map[string]interface{}{"error": err.Error()}); return C.CString(string(errMsg)) }
-	b, _ := json.Marshal(r)
-	return C.CString(string(b))
-}
-
-//export GetStagesJSON
-func GetStagesJSON(handle unsafe.Pointer) *C.char {
-	bs := getState(handle)
-	if bs == nil { return nil }
-	type se struct { Stage string ` + "`" + `json:"stage"` + "`" + ` }
-	var entries []se
-	for s := range bs.stages { entries = append(entries, se{s}) }
-	b, _ := json.Marshal(entries)
-	return C.CString(string(b))
-}
-
-//export InvokeStage
-func InvokeStage(handle unsafe.Pointer, stage *C.char, contextJSON *C.char) C.int {
-	bs := getState(handle)
-	if bs == nil || stage == nil { return 1 }
-	goStage := C.GoString(stage)
-	handler, ok := bs.stages[goStage]
-	if !ok { return 1 }
-	var ctx map[string]interface{}
-	if contextJSON != nil { json.Unmarshal([]byte(C.GoString(contextJSON)), &ctx) }
-	sc := &sdk.StageContext{}
-	if ctx != nil {
-		if v, ok := ctx["raw_message"].(string); ok { sc.RawMessage = v }
-		if v, ok := ctx["user_id"].(string); ok { sc.UserID = v }
-		if v, ok := ctx["phase"].(string); ok { sc.Phase = sdk.Stage(v) }
-	}
-	if err := handler(sc); err != nil { return 1 }
-	return 0
-}
-
-//export FreeCString
-func FreeCString(s *C.char) { C.free(unsafe.Pointer(s)) }
-
-type bridgeSettings struct{ data map[string]interface{} }
-func (s *bridgeSettings) Get(key string) (interface{}, error) { v, ok := s.data[key]; if !ok { return nil, nil }; return v, nil }
-func (s *bridgeSettings) Set(key string, value interface{}) error { s.data[key] = value; return nil }
-func (s *bridgeSettings) List(prefix string) ([]string, error) {
-	var keys []string
-	for k := range s.data { if len(k) >= len(prefix) && k[:len(prefix)] == prefix { keys = append(keys, k) } }
-	return keys, nil
-}
-func (s *bridgeSettings) GetCore(key string) (interface{}, error) { return nil, nil }
-func (s *bridgeSettings) SetCore(key string, value interface{}) error { return nil }
-func (s *bridgeSettings) ListCore(prefix string) ([]string, error) { return nil, nil }
-func (s *bridgeSettings) GetPlugin(plugin, key string) (interface{}, error) { return nil, nil }
-func (s *bridgeSettings) SetPlugin(plugin, key string, value interface{}) error { return nil }
-func (s *bridgeSettings) ListPlugin(plugin, prefix string) ([]string, error) { return nil, nil }
-func (s *bridgeSettings) RegisterDef(def sdk.ConfigDef) {}
-func (s *bridgeSettings) Defs(prefix string) []*sdk.ConfigDef { return nil }
-func (s *bridgeSettings) Dump() map[string]interface{} { return s.data }
-func (s *bridgeSettings) Plugins() []string { return nil }
-
-func main() {}
-`
-
-// tmplCABIHeader — shared C ABI type definitions for both core and plugin
-// 此模板中的常量应与 core/internal/meta/meta.go 保持一致（ABI 版本、dispatch method IDs）。
-const tmplCABIHeader = `
-#ifndef HOMEAGENT_CABI_H
-#define HOMEAGENT_CABI_H
-// HOMEAGENT_ABI_VERSION 与 sdk/meta/meta.go CABINum 同步（major*100+minor，v0.9.x→900）
-#define HOMEAGENT_ABI_VERSION 900
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// PluginAPI — implemented by the plugin, called by the core
-typedef struct {
-    int version; int version_min;
-    int (*init_plugin)(char*, char*, char**);
-    int (*start_plugin)(void*, int, char**);
-    int (*stop_plugin)(char**);
-    int (*invoke_tool)(char*, char*, char**, char**);
-    int (*invoke_stage)(char*, char*, char**, char**);
-    int (*invoke_output)(char*, char*, char*, char**);
-    void (*free_string)(char*);
-} PluginAPI;
-
-// CoreAPI — implemented by the core, passed to plugin via start_plugin
-// Uses single dispatch function to avoid function pointer ABI issues
-typedef struct {
-    int version; int version_min;
-    int (*dispatch)(int method_id, void* ctx, char* s1, char* s2, char* s3, int i1, int i2, char** result, char** error);
-    void* ctx;
-} CoreAPI;
-
-// Dispatch method IDs (plugin→core SDK calls)
-enum {
-    CORE_REGISTER_TOOL        = 1,
-    CORE_REGISTER_STAGE       = 2,
-    CORE_REGISTER_OUTPUT_CH   = 3,
-    CORE_REGISTER_PLUGIN_API  = 4,
-    CORE_INJECT_TEXT          = 5,
-    CORE_INJECT_INTERRUPT_TEXT = 6,
-    CORE_INJECT_TEXT_NO_MEMORY = 7,
-    CORE_INJECT_INPUT_SYNC    = 47,
-    CORE_SET_AUTO_RESTART     = 8,
-    CORE_MEMORY_RECALL        = 9,
-    CORE_MEMORY_COMMIT        = 10,
-    CORE_MEMORY_INTROSPECT    = 11,
-    CORE_MEMORY_MERGE         = 12,
-    CORE_MEMORY_PURGE         = 13,
-    CORE_DOC_QUERY            = 14,
-    CORE_KNOWLEDGE_SEARCH     = 15,
-    CORE_SETTINGS_GET         = 16,
-    CORE_SETTINGS_SET         = 17,
-    CORE_SETTINGS_REGISTER_DEF = 18,
-    CORE_LLM_LIST_SOURCES     = 19,
-    CORE_LLM_SET_SOURCE       = 20,
-    CORE_SOCIAL_GET_PERSON    = 21,
-    CORE_SOCIAL_GET_NETWORK   = 22,
-    CORE_SUBSCRIBE            = 23,
-    CORE_UNSUBSCRIBE          = 24,
-    CORE_FREE_STRING          = 25,
-    CORE_SETTINGS_GET_CORE     = 26,
-    CORE_SETTINGS_SET_CORE     = 27,
-    CORE_SETTINGS_LIST_CORE    = 28,
-    CORE_SETTINGS_GET_PLUGIN   = 29,
-    CORE_SETTINGS_SET_PLUGIN   = 30,
-    CORE_SETTINGS_LIST_PLUGIN  = 31,
-    CORE_DOC_INSERT            = 32,
-    CORE_DOC_REMOVE            = 33,
-    CORE_DOC_STATS             = 34,
-    CORE_KNOWLEDGE_ADD         = 35,
-    CORE_KNOWLEDGE_LIST        = 36,
-    CORE_LLM_CURRENT_SOURCE    = 37,
-    CORE_SOCIAL_GET_TRAIT      = 38,
-    CORE_SOCIAL_GET_RELATIONS  = 39,
-    CORE_SOCIAL_LIST_PERSONS   = 40,
-    CORE_TEXT_MEMORY_APPEND    = 41,
-    CORE_SETTINGS_LIST         = 42,
-    CORE_SETTINGS_DEFS         = 43,
-    CORE_SETTINGS_DUMP         = 44,
-    CORE_SETTINGS_PLUGINS      = 45,
-    CORE_REGISTER_INPUT_CH     = 46,
-};
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-`
-
-// tmplLinuxBridge — auto-generated Go bridge for Linux c-shared builds.
-// Called by plugin's Start() with a PluginSDK that wraps CoreAPI dispatch.
-// PluginSDK calls go through C ABI → CoreAPI dispatch → core's Go PluginSDK.
-const tmplLinuxBridge = `package main
-
-/*
-#include <stdlib.h>
-int ha_dispatch(int method_id, void* core_api, char* s1, char* s2, char* s3, int i1, int i2, char** result, char** error);
-*/
-import "C"
-import (
-	"encoding/json"
-	"fmt"
-	"sync"
-	"unsafe"
-	sdk "gitcode.com/JianFeeeee/homeagent-sdk/sdk"
-)
-
-// ---- global state ----
-
-var (
-	mu         sync.Mutex
-	currentPlg sdk.Plugin
-	currentSDK *sdk.PluginSDK
-	coreAPI    unsafe.Pointer
-
-	handlerMu   sync.RWMutex
-	coreAPIMu   sync.RWMutex
-	toolHandlers  = map[string]sdk.ToolHandler{}
-	stageHandlers = map[string]sdk.StageHandler{}
-	outputHandlers = map[string]sdk.ToolHandler{}
-)
-
-// ---- CoreAPI dispatch helpers ----
-
-func callVoid(methodID int, s1, s2, s3 string, i1, i2 int) error {
-	coreAPIMu.RLock()
-	api := coreAPI
-	coreAPIMu.RUnlock()
-	var c1, c2, c3 *C.char
-	if s1 != "" { c1 = C.CString(s1); defer C.free(unsafe.Pointer(c1)) }
-	if s2 != "" { c2 = C.CString(s2); defer C.free(unsafe.Pointer(c2)) }
-	if s3 != "" { c3 = C.CString(s3); defer C.free(unsafe.Pointer(c3)) }
-	var cErr *C.char
-	if C.ha_dispatch(C.int(methodID), api, c1, c2, c3, C.int(i1), C.int(i2), nil, &cErr) != 0 && cErr != nil {
-		return fmt.Errorf("%s", C.GoString(cErr))
-	}
-	return nil
-}
-
-func callString(methodID int, s1, s2, s3 string, i1, i2 int) (string, error) {
-	coreAPIMu.RLock()
-	api := coreAPI
-	coreAPIMu.RUnlock()
-	var c1, c2, c3 *C.char
-	if s1 != "" { c1 = C.CString(s1); defer C.free(unsafe.Pointer(c1)) }
-	if s2 != "" { c2 = C.CString(s2); defer C.free(unsafe.Pointer(c2)) }
-	if s3 != "" { c3 = C.CString(s3); defer C.free(unsafe.Pointer(c3)) }
-	var strResult, cErr *C.char
-	if C.ha_dispatch(C.int(methodID), api, c1, c2, c3, C.int(i1), C.int(i2), &strResult, &cErr) != 0 && cErr != nil {
-		return "", fmt.Errorf("%s", C.GoString(cErr))
-	}
-	if strResult != nil {
-		result := C.GoString(strResult)
-		C.ha_dispatch(C.int(25), api, strResult, nil, nil, 0, 0, nil, nil)
-		return result, nil
-	}
-	return "", nil
-}
-
-// ---- buildPluginSDK: PluginSDK backed by CoreAPI dispatch ----
-//   - ALL SDK methods route through C ABI → CoreAPI → core's PluginSDK
-//   - Handlers for tools/stages/output are stored locally AND registered via dispatch
-
-func buildPluginSDK(name string) *sdk.PluginSDK {
-	sett := &dispatchSettings{}
-	base := sdk.New(name, sett,
-		func(toolName string, def sdk.ToolDef, handler sdk.ToolHandler) error {
-			handlerMu.Lock()
-			toolHandlers[toolName] = handler
-			handlerMu.Unlock()
-			b, _ := json.Marshal(def)
-			return callVoid(1, toolName, string(b), "", 0, 0)
-		},
-		func(stage sdk.Stage, handler sdk.StageHandler) {
-			handlerMu.Lock()
-			stageHandlers[string(stage)] = handler
-			handlerMu.Unlock()
-			callVoid(2, string(stage), "", "", 0, 0)
-		},
-		func(name string) error { return callVoid(4, name, "", "", 0, 0) },
-		func(name string, caps int, desc string, def sdk.ChannelDef, handler sdk.ToolHandler) error {
-			handlerMu.Lock()
-			outputHandlers[name] = handler
-			handlerMu.Unlock()
-			defJSON, _ := json.Marshal(def)
-			return callVoid(3, name, desc, string(defJSON), caps, 0)
-		},
-	)
-	base.SetIOInjector(dispatchIO{})
-	base.SetMemoryAPI(dispatchMemory{})
-	base.SetDocMemoryAPI(dispatchDocMemory{})
-	base.SetKnowledgeAPI(dispatchKnowledge{})
-	base.SetLLMAPI(dispatchLLM{})
-	base.SetSocialAPI(dispatchSocial{})
-	base.SetTextMemoryAPI(dispatchTextMemory{})
-	base.SetInputChannelRegistrar(
-		func(name string, def sdk.ChannelDef) error {
-			defJSON, _ := json.Marshal(def)
-			return callVoid(46, name, string(defJSON), "", 0, 0)
-		},
-	)
-	return base
-}
-
-// ---- dispatch IO (inline definitions) ----
-
-type dispatchIO struct{}
-func (dispatchIO) InjectInterruptText(s, c, t string) { callVoid(6, s, c, t, 0, 0) }
-func (dispatchIO) InjectText(s, c, t string)           { callVoid(5, s, c, t, 0, 0) }
-func (dispatchIO) InjectTextNoMemory(s, c, t string)   { callVoid(7, s, c, t, 0, 0) }
-func (dispatchIO) InjectInputSync(s, c, t string) string { r, _ := callString(47, s, c, t, 0, 0); return r }
-
-type dispatchMemory struct{}
-func (dispatchMemory) Recall(q []string, d int) ([]sdk.Entity, []sdk.Relation, error) {
-	b, _ := json.Marshal(q); r, e := callString(9, string(b), "", "", d, 0)
-	if e != nil || r == "" { return nil, nil, e }
-	var v struct{ Entities []sdk.Entity; Relations []sdk.Relation }
-	if e = json.Unmarshal([]byte(r), &v); e != nil { return nil, nil, e }
-	if v.Entities == nil { v.Entities = []sdk.Entity{} }
-	if v.Relations == nil { v.Relations = []sdk.Relation{} }
-	return v.Entities, v.Relations, nil
-}
-func (dispatchMemory) Commit(t []sdk.Triple) error { b, _ := json.Marshal(t); return callVoid(10, string(b), "", "", 0, 0) }
-func (dispatchMemory) Introspect() (map[string]interface{}, error) { r, e := callString(11, "", "", "", 0, 0); if e != nil || r == "" { return nil, e }; var m map[string]interface{}; return m, json.Unmarshal([]byte(r), &m) }
-func (dispatchMemory) MergeEntities(s, t string) (int, error) { return 1, callVoid(12, s, t, "", 0, 0) }
-func (dispatchMemory) Purge(c map[string]string, m string) (int, error) { b, _ := json.Marshal(c); i := 0; if m == "hard" { i = 1 }; return 1, callVoid(13, string(b), "", "", i, 0) }
-
-type dispatchDocMemory struct{}
-func (dispatchDocMemory) Query(t string, k int) []*sdk.Doc { r, e := callString(14, t, "", "", k, 0); if e != nil || r == "" { return nil }; var d []*sdk.Doc; json.Unmarshal([]byte(r), &d); return d }
-func (dispatchDocMemory) Insert(doc *sdk.Doc) error { b, _ := json.Marshal(doc); return callVoid(32, string(b), "", "", 0, 0) }
-func (dispatchDocMemory) Remove(id string) { callVoid(33, id, "", "", 0, 0) }
-func (dispatchDocMemory) Stats() map[string]interface{} { r, e := callString(34, "", "", "", 0, 0); if e != nil || r == "" { return nil }; var m map[string]interface{}; json.Unmarshal([]byte(r), &m); return m }
-
-type dispatchKnowledge struct{}
-func (dispatchKnowledge) Search(q string, k int) ([]*sdk.Knowledge, error) { r, e := callString(15, q, "", "", k, 0); if e != nil || r == "" { return nil, e }; var v []*sdk.Knowledge; return v, json.Unmarshal([]byte(r), &v) }
-func (dispatchKnowledge) Add(n, c string) error { return callVoid(35, n, c, "", 0, 0) }
-func (dispatchKnowledge) List() ([]string, error) { r, e := callString(36, "", "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v []string; return v, json.Unmarshal([]byte(r), &v) }
-
-type dispatchLLM struct{}
-func (dispatchLLM) ListSources() []string { r, e := callString(19, "", "", "", 0, 0); if e != nil || r == "" { return nil }; var v []string; json.Unmarshal([]byte(r), &v); return v }
-func (dispatchLLM) SetSource(n string) error { return callVoid(20, n, "", "", 0, 0) }
-func (dispatchLLM) CurrentSource() string { r, e := callString(37, "", "", "", 0, 0); if e != nil || r == "" { return "" }; return r }
-
-type dispatchSocial struct{}
-func (dispatchSocial) GetPerson(n string) (*sdk.PersonProfile, error) { r, e := callString(21, n, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v sdk.PersonProfile; return &v, json.Unmarshal([]byte(r), &v) }
-func (dispatchSocial) GetTrait(n, t string) (string, bool) { r, e := callString(38, n, t, "", 0, 0); if e != nil || r == "" { return "", false }; var m map[string]interface{}; json.Unmarshal([]byte(r), &m); v, _ := m["value"].(string); ok, _ := m["found"].(bool); return v, ok }
-func (dispatchSocial) GetRelations(name string) ([]sdk.SocialRelation, error) { r, e := callString(39, name, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v []sdk.SocialRelation; return v, json.Unmarshal([]byte(r), &v) }
-func (dispatchSocial) GetNetwork(n string, d int) ([]*sdk.PersonProfile, error) { r, e := callString(22, n, "", "", d, 0); if e != nil || r == "" { return nil, e }; var v []*sdk.PersonProfile; return v, json.Unmarshal([]byte(r), &v) }
-func (dispatchSocial) ListPersons() ([]string, error) { r, e := callString(40, "", "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v []string; return v, json.Unmarshal([]byte(r), &v) }
-
-type dispatchTextMemory struct{}
-func (dispatchTextMemory) Append(evt sdk.TextEvent) error { b, _ := json.Marshal(evt); return callVoid(41, string(b), "", "", 0, 0) }
-
-// ---- dispatchSettings (inline) ----
-
-type dispatchSettings struct{}
-func (d *dispatchSettings) Get(key string) (interface{}, error) {
-	r, e := callString(16, key, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v interface{}; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) Set(key string, value interface{}) error {
-	b, _ := json.Marshal(value); return callVoid(17, key, string(b), "", 0, 0)
-}
-func (d *dispatchSettings) RegisterDef(def sdk.ConfigDef) { b, _ := json.Marshal(def); callVoid(18, string(b), "", "", 0, 0) }
-func (d *dispatchSettings) List(prefix string) ([]string, error) {
-	r, e := callString(42, prefix, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v []string; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) GetCore(key string) (interface{}, error) {
-	r, e := callString(26, key, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v interface{}; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) SetCore(key string, value interface{}) error {
-	b, _ := json.Marshal(value); return callVoid(27, key, string(b), "", 0, 0)
-}
-func (d *dispatchSettings) ListCore(prefix string) ([]string, error) {
-	r, e := callString(28, prefix, "", "", 0, 0); if e != nil || r == "" { return nil, e }; var v []string; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) GetPlugin(plugin, key string) (interface{}, error) {
-	r, e := callString(29, plugin, key, "", 0, 0); if e != nil || r == "" { return nil, e }; var v interface{}; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) SetPlugin(plugin, key string, value interface{}) error {
-	b, _ := json.Marshal(value); return callVoid(30, plugin, key, string(b), 0, 0)
-}
-func (d *dispatchSettings) ListPlugin(plugin, prefix string) ([]string, error) {
-	r, e := callString(31, plugin, prefix, "", 0, 0); if e != nil || r == "" { return nil, e }; var v []string; return v, json.Unmarshal([]byte(r), &v)
-}
-func (d *dispatchSettings) Defs(prefix string) []*sdk.ConfigDef {
-	r, e := callString(43, prefix, "", "", 0, 0); if e != nil || r == "" { return nil }; var v []*sdk.ConfigDef; json.Unmarshal([]byte(r), &v); return v
-}
-func (d *dispatchSettings) Dump() map[string]interface{} {
-	r, e := callString(44, "", "", "", 0, 0); if e != nil || r == "" { return nil }; var m map[string]interface{}; json.Unmarshal([]byte(r), &m); return m
-}
-func (d *dispatchSettings) Plugins() []string {
-	r, e := callString(45, "", "", "", 0, 0); if e != nil || r == "" { return nil }; var v []string; json.Unmarshal([]byte(r), &v); return v
-}
-
-// ---- Go callbacks (called from z_entry.c via C) ----
-
-//export go_init_plugin
-func go_init_plugin(name *C.char, configJSON *C.char, errorOut **C.char) C.int {
-	plg, err := NewPluginFactory(C.GoString(name), nil)
-	if err != nil || plg == nil {
-		if err != nil { *errorOut = C.CString(err.Error()) } else { *errorOut = C.CString("NewPluginFactory returned nil") }
-		return 1
-	}
-	mu.Lock(); currentPlg = plg; mu.Unlock()
-	_ = configJSON
-	return 0
-}
-
-//export go_start_plugin
-func go_start_plugin(coreAPIptr unsafe.Pointer, coreVersion C.int, errorOut **C.char) C.int {
-	mu.Lock()
-	plg := currentPlg
-	coreAPIMu.Lock()
-	coreAPI = coreAPIptr
-	coreAPIMu.Unlock()
-	mu.Unlock()
-	_ = coreVersion
-	if plg == nil { *errorOut = C.CString("not initialized"); return 1 }
-	sdk := buildPluginSDK(plg.Name())
-	mu.Lock(); currentSDK = sdk; mu.Unlock()
-	if err := plg.Start(sdk); err != nil { *errorOut = C.CString(err.Error()); return 1 }
-	return 0
-}
-
-//export go_stop_plugin
-func go_stop_plugin(errorOut **C.char) C.int {
-	mu.Lock()
-	plg := currentPlg
-	sdk := currentSDK
-	currentPlg = nil
-	currentSDK = nil
-	coreAPIMu.Lock()
-	coreAPI = nil
-	coreAPIMu.Unlock()
-	mu.Unlock()
-	if sdk != nil {
-		sdk.RunStopHandlers()
-	}
-	if plg != nil {
-		if err := plg.Stop(); err != nil { *errorOut = C.CString(err.Error()); return 1 }
-	}
-	return 0
-}
-
-//export go_invoke_tool
-func go_invoke_tool(name *C.char, argsJSON *C.char, resultOut **C.char, errorOut **C.char) C.int {
-	goName := C.GoString(name)
-	handlerMu.RLock()
-	h, ok := toolHandlers[goName]
-	handlerMu.RUnlock()
-	if !ok { *errorOut = C.CString("tool not found"); return 1 }
-	var args map[string]interface{}
-	if argsJSON != nil { json.Unmarshal([]byte(C.GoString(argsJSON)), &args) }
-	r, err := h(args)
-	if err != nil { *errorOut = C.CString(err.Error()); return 1 }
-	b, _ := json.Marshal(r)
-	*resultOut = C.CString(string(b))
-	return 0
-}
-
-// fillStageContext 将内核传来的 ctx JSON 填充到插件侧 StageContext。
-func fillStageContext(sc *sdk.StageContext, ctxJSON string) {
-	var m map[string]interface{}
-	if err := json.Unmarshal([]byte(ctxJSON), &m); err != nil {
-		return
-	}
-	if v, _ := m["raw_message"].(string); v != "" { sc.RawMessage = v }
-	if v, _ := m["user_id"].(string); v != "" { sc.UserID = v }
-	if v, _ := m["group_id"].(string); v != "" { sc.GroupID = v }
-	if v, _ := m["phase"].(string); v != "" { sc.Phase = sdk.Stage(v) }
-	if v, _ := m["llm_text"].(string); v != "" { sc.LLMText = v }
-	if v, _ := m["final_text"].(string); v != "" { sc.FinalText = v }
-	if v, _ := m["no_memory"].(bool); v { sc.NoMemory = true }
-	if v, _ := m["response"].(string); v != "" { sc.Response = &v }
-	if v, _ := m["tool_calls"].([]interface{}); len(v) > 0 {
-		b, _ := json.Marshal(v); json.Unmarshal(b, &sc.ToolCalls)
-	}
-	if v, _ := m["tool_results"].([]interface{}); len(v) > 0 {
-		b, _ := json.Marshal(v); json.Unmarshal(b, &sc.ToolResults)
-	}
-}
-
-// stageContextWritable 提取插件可写且内核会同步回去的字段。
-func stageContextWritable(sc *sdk.StageContext) map[string]interface{} {
-	m := map[string]interface{}{
-		"raw_message": sc.RawMessage,
-		"user_id":     sc.UserID,
-		"group_id":    sc.GroupID,
-		"phase":       string(sc.Phase),
-		"llm_text":    sc.LLMText,
-		"final_text":  sc.FinalText,
-		"no_memory":   sc.NoMemory,
-	}
-	if sc.Response != nil {
-		m["response"] = *sc.Response
-	}
-	if len(sc.ToolCalls) > 0 {
-		m["tool_calls"] = sc.ToolCalls
-	}
-	if len(sc.ToolResults) > 0 {
-		m["tool_results"] = sc.ToolResults
-	}
-	return m
-}
-
-//export go_invoke_stage
-func go_invoke_stage(stage *C.char, ctxJSON *C.char, resultOut **C.char, errorOut **C.char) C.int {
-	goStage := C.GoString(stage)
-	handlerMu.RLock()
-	h, ok := stageHandlers[goStage]
-	handlerMu.RUnlock()
-	if !ok { return 0 }
-	sc := &sdk.StageContext{}
-	if ctxJSON != nil {
-		fillStageContext(sc, C.GoString(ctxJSON))
-	}
-	if err := h(sc); err != nil { *errorOut = C.CString(err.Error()); return 1 }
-	// ABI v2: 回传插件修改后的上下文（若调用方要求）
-	if resultOut != nil {
-		if b, err := json.Marshal(stageContextWritable(sc)); err == nil {
-			*resultOut = C.CString(string(b))
-		}
-	}
-	return 0
-}
-
-//export go_invoke_output
-func go_invoke_output(channel *C.char, msgType *C.char, payloadJSON *C.char, errorOut **C.char) C.int {
-	goChan := C.GoString(channel)
-	handlerMu.RLock()
-	h, ok := outputHandlers[goChan]
-	handlerMu.RUnlock()
-	if !ok { return 0 }
-	// payloadJSON contains the full args JSON from output_send (e.g. {"content":"...","user_id":123})
-	var args map[string]interface{}
-	if payloadJSON != nil {
-		json.Unmarshal([]byte(C.GoString(payloadJSON)), &args)
-	}
-	if _, err := h(args); err != nil { *errorOut = C.CString(err.Error()); return 1 }
-	return 0
-}
-
-//export go_free_string
-func go_free_string(ptr *C.char) { C.free(unsafe.Pointer(ptr)) }
-
-func main() {}
-`
-
-// tmplPluginInitC — C entry point for the plugin .so file.
-// Contains PluginAPI, CoreAPI (single dispatch), and ha_dispatch bridge.
-const tmplPluginInitC = `#include <stdlib.h>
-#include <string.h>
-
-// HOMEAGENT_ABI_VERSION 与 sdk/meta/meta.go CABINum 同步（major*100+minor，v0.9.x→900）
-#define HOMEAGENT_ABI_VERSION 900
-
-typedef struct {
-    int version; int version_min;
-    int (*init_plugin)(char*, char*, char**);
-    int (*start_plugin)(void*, int, char**);
-    int (*stop_plugin)(char**);
-    int (*invoke_tool)(char*, char*, char**, char**);
-    int (*invoke_stage)(char*, char*, char**, char**);
-    int (*invoke_output)(char*, char*, char*, char**);
-    void (*free_string)(char*);
-} PluginAPI;
-
-typedef struct {
-    int version; int version_min;
-    int (*dispatch)(int, void*, char*, char*, char*, int, int, char**, char**);
-    void* ctx;
-} CoreAPI;
-
-extern int go_init_plugin(char*, char*, char**);
-extern int go_start_plugin(void*, int, char**);
-extern int go_stop_plugin(char**);
-extern int go_invoke_tool(char*, char*, char**, char**);
-extern int go_invoke_stage(char*, char*, char**, char**);
-extern int go_invoke_output(char*, char*, char*, char**);
-extern void go_free_string(char*);
-
-int c_init_plugin(char* n, char* c, char** e) { return go_init_plugin(n, c, e); }
-int c_start_plugin(void* a, int v, char** e) { return go_start_plugin(a, v, e); }
-int c_stop_plugin(char** e) { return go_stop_plugin(e); }
-int c_invoke_tool(char* n, char* a, char** r, char** e) { return go_invoke_tool(n, a, r, e); }
-int c_invoke_stage(char* s, char* c, char** r, char** e) { return go_invoke_stage(s, c, r, e); }
-int c_invoke_output(char* c, char* m, char* p, char** e) { return go_invoke_output(c, m, p, e); }
-void c_free_string(char* p) { go_free_string(p); }
-
-// ha_dispatch — called by Go bridge, passes through to CoreAPI dispatch
-int ha_dispatch(int id, void* api, char* s1, char* s2, char* s3, int i1, int i2, char** r, char** e) {
-    CoreAPI* a = (CoreAPI*)api;
-    if (!a || !a->dispatch) return 1;
-    return a->dispatch(id, a->ctx, s1, s2, s3, i1, i2, r, e);
-}
-
-PluginAPI* plugin_init(void) {
-    static PluginAPI api;
-    memset(&api, 0, sizeof(api));
-    api.version = HOMEAGENT_ABI_VERSION; api.version_min = HOMEAGENT_ABI_VERSION;
-    api.init_plugin = c_init_plugin; api.start_plugin = c_start_plugin; api.stop_plugin = c_stop_plugin;
-    api.invoke_tool = c_invoke_tool; api.invoke_stage = c_invoke_stage; api.invoke_output = c_invoke_output;
-    api.free_string = c_free_string;
-    return &api;
-}
-`
-
-const tmplReadme = `# {{.Plg.Name}}
-
-{{.Plg.Description}}
-
-## Build
-
-` + "```bash" + `
-plugindev build
-` + "```" + `
-
-## Install
-
-Upload the .hmap file through the Plugin Manager API.
-`