@tiechui/cli 0.3.0 → 0.4.1-darwin-arm64

package/chui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/chui
+size: 39591328 bytes
+sha256: 1f2623cf3eab45dd9b2c7567d4b944ce2f804ce62536bd5a0440e1f7e47066ed

package/package.json

@@ -6,23 +6,15 @@
     "url": "git+https://github.com/b1ank1108/tiechui.git"
   },
   "name": "@tiechui/cli",
-  "version": "0.3.0",
-  "description": "A terminal coding agent written in Rust",
-  "bin": {
-    "chui": "bin/chui.js",
-    "tiechui": "bin/chui.js"
-  },
-  "files": [
-    "bin"
+  "version": "0.4.1-darwin-arm64",
+  "os": [
+    "darwin"
   ],
-  "engines": {
-    "node": ">=16"
-  },
-  "optionalDependencies": {
-    "@tiechui/cli-darwin-arm64": "npm:@tiechui/cli@0.3.0-darwin-arm64",
-    "@tiechui/cli-darwin-x64": "npm:@tiechui/cli@0.3.0-darwin-x64",
-    "@tiechui/cli-linux-arm64": "npm:@tiechui/cli@0.3.0-linux-arm64",
-    "@tiechui/cli-linux-x64": "npm:@tiechui/cli@0.3.0-linux-x64",
-    "@tiechui/cli-win32-x64": "npm:@tiechui/cli@0.3.0-win32-x64"
-  }
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "chui",
+    "rg"
+  ]
 }

package/LICENSE

@@ -1,661 +0,0 @@
-                    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/>.

package/README.md

@@ -1,568 +0,0 @@
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset=".github/assets/logo-dark.svg">
-    <img src=".github/assets/logo.svg" width="130" alt="Tiechui">
-  </picture>
-</p>
-
-<h1 align="center">Tiechui · 铁锤</h1>
-
-<p align="center">
-  A terminal coding agent written in Rust.<br>
-  One binary, installed as <code>chui</code> and <code>tiechui</code>, with an interactive terminal UI and a headless <code>exec</code>.
-</p>
-
-<p align="center">
-  <img alt="Rust 1.95" src="https://img.shields.io/badge/Rust-1.95-8fa8c9?style=flat-square&logo=rust&logoColor=white">
-  <img alt="macOS | Linux | Windows" src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-a99ccf?style=flat-square">
-  <img alt="Anthropic · OpenAI" src="https://img.shields.io/badge/wires-Anthropic%20%C2%B7%20OpenAI-8fb996?style=flat-square">
-  <a href="LICENSE"><img alt="AGPL-3.0" src="https://img.shields.io/badge/license-AGPL--3.0-d6b07a?style=flat-square"></a>
-</p>
-
-<p align="center">
-  <b>English</b> · <a href="README.zh-CN.md">简体中文</a> · <a href="https://b1ank1108.github.io/tiechui/">UI gallery</a>
-</p>
-
-<p align="center">
-  <img src=".github/assets/tui.png" width="720" alt="chui in a terminal: the session header, a turn with tool calls, a diff and a background shell, the composer, the status line in auto mode and the background activity row">
-</p>
-
-## Highlights
-
-- **Two provider wires.** Anthropic Messages and OpenAI Chat Completions, including compatible gateways.
-- **Sessions you can rewind.** Append-only JSONL with branches, resume, rewind and compaction.
-- **A permission gate.** Rules for tools, shell commands, paths and MCP calls, in three modes: `rules`, `auto` (a model reviews what the rules would ask about) and `yolo`.
-- **Background shells.** Long-running commands move to the background; the model is told when they finish.
-- **Modules.** Questions, side chats, goals, scheduled prompts, subagents, skills, prompt templates, hooks and MCP.
-- **Plugins.** Declarative T1 packages, out-of-process T2 JSON-RPC plugins with Rust and TypeScript SDKs, and a Git marketplace.
-
-The interactive UI and `exec` run on the same session actor, providers, tools,
-permissions and modules.
-
-[Quick start](#quick-start) · [Install](#install) · [Configure](#configure) ·
-[Use](#use) · [UI gallery](#ui-gallery) · [Permissions](#permissions-and-trust) ·
-[Extend](#extend) · [Develop](#develop) · [Status](#status) · [License](#license)
-
-## Quick start
-
-```sh
-npm i -g @tiechui/cli
-chui
-```
-
-With no provider configured, `chui` asks for the service, address, key and model,
-lists the models the service offers, checks them with one request and saves the
-answers to `~/.tiechui`. `chui setup` adds another provider later.
-
-## Install
-
-macOS, Linux and Windows (x64) are supported. Content search uses ripgrep,
-which npm, the install scripts and the release archives bundle; file discovery
-and `@` completion are built in. On Windows the bash tool runs
-through Git Bash from [Git for Windows](https://git-scm.com/download/win); set
-`TIECHUI_GIT_BASH_PATH` if it is not found automatically.
-
-**npm.**
-
-```sh
-npm i -g @tiechui/cli
-```
-
-Node 16 or later runs the native build for your platform, which npm installs as
-an optional dependency. pnpm, yarn and bun work too.
-
-**macOS and Linux.**
-
-```sh
-curl -fsSL https://github.com/b1ank1108/tiechui/releases/latest/download/install.sh | sh
-```
-
-It verifies the archive against `SHA256SUMS`, installs `chui` and `tiechui`
-into `~/.local/bin`, and puts the bundled `rg` in `~/.local/libexec/tiechui`,
-where it does not replace an `rg` you already have. Set `TIECHUI_VERSION` to pin
-a release or `TIECHUI_INSTALL_DIR` to choose another directory; `rg` then goes
-to `libexec/tiechui` beside that directory's parent.
-
-**Windows (PowerShell).**
-
-```powershell
-irm https://github.com/b1ank1108/tiechui/releases/latest/download/install.ps1 | iex
-```
-
-It installs `chui.exe`, `tiechui.exe` and the bundled `rg.exe` into
-`%LOCALAPPDATA%\Programs\tiechui` and adds that directory to the user `Path`.
-The same variables apply.
-
-Building from source needs Rust through rustup (the checkout pins **1.95.0**
-with rustfmt and clippy) and Git.
-
-**From source.** `cargo install --locked --path crates/tiechui-cli --root
-<prefix>` installs `chui` and `tiechui` into `<prefix>/bin`, without `rg`:
-content search then uses `rg` from `PATH` or `~/.tiechui/bin`. For development,
-`cargo run --locked --bin chui -- --help` runs without installing.
-
-**Managed install from a source checkout (macOS and Linux).** Build a tarball
-with `cargo xtask dist`, or download one from a GitHub Release, then:
-
-```sh
-cargo xtask install tiechui-VERSION-TARGET.tar.gz --prefix ~/.local
-~/.local/bin/chui doctor --prefix ~/.local
-cargo xtask uninstall --prefix ~/.local
-```
-
-The installer has no default prefix. It:
-
-- validates the archive and its manifest, including the bundled `rg`, which it
-  does not install (content search uses `rg` from `PATH`);
-- records the hash of each binary it owns in `<prefix>/.tiechui-install/`;
-- refuses to replace commands it did not install, including a `cargo install` copy;
-- repairs moved or partial installs;
-- rolls interrupted runs back through a journal.
-
-Installation never touches the profile or your sessions. `cargo xtask
-verify-release` runs the full release checks against a candidate.
-
-## Configure
-
-The profile directory is `$TIECHUI_HOME`, default `~/.tiechui`:
-
-| Path | Contents |
-| --- | --- |
-| `config.toml` | Model selection, modules, permissions, MCP servers, UI |
-| `providers.toml` | Providers and their models |
-| `sessions/` | Session logs, grouped by working directory |
-| `trust.json` | Project trust decisions |
-| `plugins/`, `plugin-grants/`, `plugin-data/` | Installed packages, capability grants, plugin data |
-| `mcp-oauth/` | MCP OAuth tokens (0600) |
-| `agents/`, `themes/` | User subagent definitions, extra `.tmTheme` files |
-| `state/` | Rewind, compaction and subagent state |
-
-Configuration layers are applied in this order:
-
-1. built-in defaults;
-2. `~/.tiechui/config.toml`;
-3. the nearest project's `.agents/config.toml` (or `.claude/config.toml`);
-4. CLI flags.
-
-Project files are searched up to the Git root and are ignored until you trust
-the project. Providers come only from `~/.tiechui/providers.toml`; no project
-or CLI layer can add or change them. There is no built-in model catalog, so you
-declare every model.
-
-The closest config wins; at the same directory `.agents/config.toml` takes
-precedence over `.claude/config.toml`. Both use Tiechui's TOML schema. Supported
-hooks can also come from `.claude/settings.json` and `.claude/settings.local.json`;
-other Claude settings are not imported. Project `.tiechui/` resources are ignored.
-The user profile remains `$TIECHUI_HOME` (default `~/.tiechui`).
-
-[examples/config.toml](examples/config.toml) lists every supported configuration
-field with explanations, and [examples/providers.toml](examples/providers.toml)
-does the same for providers. Active entries preserve default behavior; optional
-settings and non-default examples are commented out. `chui setup` writes the
-minimal setup below for you: your own endpoint and model, then selects it.
-
-`~/.tiechui/providers.toml`, where each top-level table is one provider:
-
-```toml
-[gateway]
-wire = "openai-completions"            # or "openai-responses", "anthropic-messages"
-base_url = "https://gateway.example"   # /v1 is added unless the URL has a version
-api_key_env = "GATEWAY_API_KEY"        # or api_key = "..." to write the key inline
-
-[gateway.compat]                       # only for non-OpenAI services
-thinking_format = "deepseek"
-max_tokens_field = "max_tokens"
-requires_reasoning_content_on_assistant_messages = true
-
-[[gateway.models]]
-id = "example-model"
-context_window = 400000
-max_output = 131072
-reasoning = true
-images = true
-```
-
-`~/.tiechui/config.toml`:
-
-```toml
-model = "gateway/example-model"        # <provider>/<model id>
-thinking = "high"                      # off | minimal | low | medium | high | xhigh | max
-
-[tui]
-theme = "automatic"                    # follows the terminal background
-
-[modules]
-# goal = false                         # every built-in module is on by default
-```
-
-- If `base_url` is omitted, the default is `https://api.anthropic.com` or
-  `https://api.openai.com`, depending on the wire. A URL without a version
-  segment gets `/v1`; one that has its own, such as `/api/paas/v4`, is kept.
-- The `compat` table adapts the request to services such as DeepSeek-style
-  reasoning gateways. A model's own `compat` table overrides single members, for
-  gateways that mix model families.
-- Thinking levels are clamped to what the model declares in `thinking_levels`.
-  On `openai-responses`, off sends effort `none`; for a model without it, map
-  `off` to `"minimal"` or mark it `false`.
-- Models can also set `cache_retention`, `prices` and, on Anthropic,
-  `fallback_models`.
-- `[network]` sets a proxy, hosts that bypass it and an extra CA file for model
-  and MCP requests. It, `[sessions]` (`archive_after_days`) and `[skills]`
-  (`disabled`, skill names that sessions leave out) are read only from
-  `~/.tiechui/config.toml`.
-
-Each provider takes its key from `api_key` in `providers.toml` or from the
-environment variable named by `api_key_env`, never both. An inline key stays out
-of the environment that tools inherit; keep the file private with `chmod 600`,
-which `chui doctor` checks. Tiechui does not load any secrets file itself, so with
-`api_key_env` export the variable in the shell that starts `chui`.
-[schema/config.json](schema/config.json) and
-[schema/providers.json](schema/providers.json) are the complete key references, and
-[crates/tiechui-providers](crates/tiechui-providers/README.md) covers wire
-compatibility.
-
-## Use
-
-```sh
-chui                                         # interactive, current directory
-chui --cwd ~/src/app --model gateway/example-model --thinking high
-chui --mode auto                             # permission mode for this run
-chui --resume                                # pick a saved session
-chui --resume SESSION_ID
-chui exec "Explain the failing tests"        # headless, prints the answer
-chui exec "Continue" --resume SESSION_ID --json --approval allow-listed
-```
-
-`chui exec` accepts:
-
-- `--model`, `--thinking`, `--mode` and `--cwd`;
-- `--resume ID` (headless resume always needs an ID);
-- `--json`, which prints protocol events;
-- `--approval`, described in [Permissions and trust](#permissions-and-trust).
-
-Other subcommands are `setup`, `doctor`, `trust`, `plugin`, `skills`, `hooks`
-and `mcp`, and each has `--help`. `chui app-server` serves sessions to desktop
-clients over JSON-RPC on stdio, along with files, Git and terminals for their projects and the user's providers, settings, MCP servers, skills, prompts, agents and hooks; its types are generated in `schema/app-server.ts`. The built-in tools are `read`, `write`, `edit`,
-`grep`, `find` and `bash`, plus `shell_list`, `shell_output` and `shell_stop` for
-background commands. Modules, plugins and MCP servers add more.
-
-### Keys
-
-| Key | Action |
-| --- | --- |
-| Enter | Send. While a turn is running, this queues steering for after the next tool call |
-| Tab | Queue a follow-up; complete a menu item |
-| Shift+Enter, Ctrl+J | New line |
-| Up / Down | Input history |
-| Alt+S | Stash or restore the draft |
-| Esc | Stop the running turn. When idle, press twice to clear the draft; with an empty composer, twice opens rewind |
-| Ctrl+O | Expanded transcript (scroll, select, copy) |
-| Ctrl+V | Attach a clipboard image (PNG, JPEG, GIF, WebP, up to 20 MiB) |
-| Ctrl+/ | Switch between the main chat and the side chat (`/btw`) |
-| Alt+Left / Alt+Right | Open the subagent viewer (empty composer) |
-| Ctrl+C | Clear input; press again to exit. Ctrl+D exits from an empty composer |
-
-In the composer:
-
-- `/` opens commands above the composer: Tab completes, Enter runs.
-- `@` finds files and directories. Tab enters a directory; Enter inserts an `@path` reference. Shift+Tab switches to All, including plugins, skills and tasks.
-- `$` selects a skill by name or description; Tab/Enter inserts its bound reference. Its instructions load when you send the message.
-- `!command` runs a shell command through the permission gate. Like the model's commands, it shows in `/shells` and can move to the background.
-
-The status line below the composer shows the model, directory and branch on the
-left, and the permission mode (outside `rules`) and remaining context on the
-right. A second row appears only while something runs in the background: shells,
-a goal or scheduled tasks. `/statusline` chooses the items. See
-[crates/tiechui-tui](crates/tiechui-tui/README.md).
-
-### Slash commands
-
-| Command | Purpose |
-| --- | --- |
-| `/model [provider/id]`, `/thinking [level]` | Switch model or thinking level and save it as the default for new sessions |
-| `/new`, `/resume`, `/retry` | New session, saved session, retry the failed request |
-| `/reload` | Reload config, context files, skills, prompts, MCP, plugins and hooks |
-| `/compact [instructions]` | Summarize older context now |
-| `/context [system\|tools\|injections\|messages\|cache]` | Inspect what is sent to the model |
-| `/rewind [detach]` | Restore code, conversation or both to an earlier turn |
-| `/btw [question]`, `/btw model [provider/id]` | Side question on a snapshot of the main context |
-| `/goal [objective]`, `/goal edit\|pause\|resume\|clear` | Persistent goal that continues while idle |
-| `/loop [interval] <prompt>`, `/cron-list`, `/cron-delete <id>` | Run a prompt now and on an interval; list or cancel scheduled tasks |
-| `/subagents` | Child tasks and their output |
-| `/shells [output\|background\|stop <id>]` | Shell tasks: view output, move a running command to the background, stop it |
-| `/permissions [rules\|auto\|yolo\|show]` | Switch the mode and save it as the default, or show rules, grants and recent decisions |
-| `/status` | Module state, config paths, diagnostics |
-| `/trust [allow\|deny]` | Project trust |
-| `/skills` | Insert a skill into the draft; use `chui skills list` outside the TUI |
-| `/mcp`, `/hooks` | Integration views |
-| `/theme`, `/statusline` | Syntax theme picker, status line items |
-| `/help`, `/quit` | Shortcuts, exit |
-
-Disabling a module removes its commands. Plugins and [prompt templates](#skills-prompts-context-files-and-hooks) can add commands.
-
-### Features
-
-- **Background shells.**
-  - The model sets `background: true` on `bash` for servers and watchers. After half a second it gets a task ID with the output so far, or the whole result if the command already ended, and it is told when the command finishes; `shell_output` reads newer output and `shell_stop` stops it. The timeout still applies.
-  - `/shells` lists running and recent commands. In the panel, `b` moves a running command to the background, `x` stops it, Enter shows its output and Esc closes.
-  - Background tasks end with the session. Subagents run commands in the foreground only.
-
-  [modules/exec](modules/exec/src/lib.rs)
-- **Rewind.** It previews the tracked edits before restoring them, and it keeps
-  the abandoned branch. It is not a filesystem snapshot: changes made by shell
-  commands or outside Tiechui are not restored.
-  [modules/rewind](modules/rewind/README.md)
-- **Side chat.**
-  - `/btw` uses tools on a frozen reference copy of the main context. Reads and
-    searches are allowed; workspace changes require an explicit side-chat request
-    and still pass the normal permissions. The filesystem is shared.
-  - Ctrl+S shares the last answer with the main chat.
-  - Otherwise the side chat is discarded on reload or restart.
-
-  [modules/btw](modules/btw/README.md)
-- **Goals.**
-  - A goal lives on the current branch and can keep the agent working while idle.
-  - Esc or Ctrl+C pauses it. After a restart it waits for input or `/goal resume`.
-
-  [modules/goal](modules/goal/README.md)
-- **Scheduled prompts.**
-  - `/loop 5m <prompt>` runs the prompt now and then every 5 minutes while the session is idle.
-  - The model can schedule one-shot or recurring prompts with cron expressions in local time.
-  - Tasks are session-only unless saved to the trusted project's `.agents/scheduled_tasks.json`; recurring tasks expire after 7 days.
-
-  [modules/loop](modules/loop/README.md)
-- **Compaction.**
-  - Native compaction runs near the context limit and on a recoverable overflow.
-  - Range compaction adds the tools `context_status`, `compact_history`, `search_history` and `read_history`.
-  - The session log is never rewritten.
-
-  [modules/compaction](modules/compaction/README.md)
-- **Subagents.**
-  - The `subagent` tool runs built-in or user-defined agents: `scout`, `planner`, `reviewer`, `worker`, or `agents/*.md` from the profile or project.
-  - A dispatch is one task, a parallel batch, or a chain. A batch takes up to 8 tasks and runs 4 at once.
-  - Children have their own sessions and grants, within the parent's policy.
-
-  [modules/subagents](modules/subagents/README.md)
-
-## UI gallery
-
-The [UI gallery](https://b1ank1108.github.io/tiechui/) shows the terminal UI
-screen by screen, in dark and light themes, at 80 and 40 columns and at three
-color levels, rendered cell by cell from the TUI snapshot tests. Its source is
-[`site/`](site/); `python3 scripts/ui_gallery.py` refreshes its data after
-snapshot changes, and `.github/workflows/pages.yml` publishes it from `main`.
-
-## Permissions and trust
-
-Permissions are a **rule gate, not an OS sandbox**.
-
-- **What is checked.** Every tool call, shell command (parsed with tree-sitter),
-  path and MCP call passes the interceptor. Once allowed, a program runs with
-  Tiechui's full user rights and inherits its environment, including exported
-  provider keys.
-- **Rules.** Each rule has a `surface`, a `pattern`, an `action` (`allow`, `ask`
-  or `deny`) and an optional `reason` for denies. Within a surface, the last
-  matching rule wins, and an explicit deny always wins.
-- **Defaults.** Reading and searching tools, session tools, MCP metadata and
-  read-only shell commands are allowed; everything else asks. Setting
-  `permissions.rules = []` drops the default tool allows.
-- **Prompts.** You can allow once, allow the shown scope for the session, or
-  deny. Session grants are not restored on resume.
-
-The **mode** decides what happens to a call the rules would ask about:
-
-| Mode | Behavior |
-| --- | --- |
-| `rules` (default) | You are asked |
-| `auto` | Edits inside the workspace pass. Anything else is reviewed by a one-off request to the session's model: allowed calls run, blocked calls return the reason to the model. After 3 blocks in a row or 20 in a session, or without model access, you are asked. Broad `bash` allows (`*`, interpreters, `npm run`, …) are ignored, so those commands are reviewed too |
-| `yolo` | Approved |
-
-Set the mode with `permissions.mode` in the user config (project config cannot
-set it), or `--mode` for one run. `/permissions <mode>` switches the current
-session and saves the mode to `permissions.mode`, so a saved `yolo` applies to
-every later session until you switch back.
-In every mode, explicit denies apply, and writes to **protected paths** ask unless
-a user rule allows them: `.git`, `.agents`, `.claude`, `.tiechui`, `.vscode`,
-`.idea`, shell profiles, `.gitconfig`, `.mcp.json` and `.env` files. Invalid
-project rules never pass without you.
-
-Headless runs choose `--approval`:
-
-| Value | Behavior |
-| --- | --- |
-| `allow-listed` (default) | Calls that still need you fail as tool errors |
-| `deny` | Every intercepted call is denied |
-| `yolo` | Same as `--mode yolo` when `--mode` is absent |
-
-`chui trust allow|deny|status --cwd DIR` (or `/trust`) decides whether a project's
-`.agents/` configuration, rules, skills, prompts and hooks load, with `.claude/`
-compatibility. Command hooks and T2 plugin capabilities have their own approvals. See
-[modules/permissions](modules/permissions/README.md).
-
-The first time `chui` opens a project with such files, it asks and saves the answer
-for the Git root. It then asks about any new or changed command hooks. Your home
-directory and its parents are never saved this way, because every project below
-would inherit them; use `chui trust allow` there. `chui exec` never asks: it skips
-undecided project content and warns.
-
-## Extend
-
-### Plugins
-
-- **T1 plugins** are declarative packages of skills, MCP servers and hooks.
-- **T2 plugins** are separate processes speaking newline-delimited JSON-RPC 2.0.
-  - They can add tools, commands, interceptors and panels.
-  - Their capabilities need an interactive grant tied to the package's content hash. A changed package asks again.
-  - Headless runs need the grant to already exist.
-
-```sh
-chui plugin marketplace add ~/src/tiechui-plugins --ref main   # a local clone or a public Git URL
-chui plugin add sdk-typescript@tiechui-plugins
-chui plugin list --json
-chui plugin upgrade [NAME]        # explicit only; shows what changed
-chui plugin remove NAME
-chui plugin add ./path/to/package # local package
-```
-
-Marketplaces use Codex's `marketplace.json` layout. Installs are pinned to the
-resolved commit and content hash. Git runs with your config isolated and no
-credentials of its own, so a private marketplace is added from a local clone.
-The official example marketplace, `tiechui-plugins`, is not public yet.
-
-Further reading:
-
-- the [Rust SDK](crates/tiechui-plugin-sdk/README.md)
-- the [TypeScript SDK](sdk/typescript/README.md): dependency-free, Node 25, no npm step
-
-### Skills, prompts, context files and hooks
-
-**Skills** are loaded from:
-
-- `.agents/skills` and `.claude/skills` in your home directory
-  and in trusted projects;
-- the profile's `skills/`.
-
-These roots are discovered by default; `[skills] disabled` leaves named skills out.
-List skills with `chui skills list`, or select one with `/skills` in the TUI. `AGENTS.md` and the other context files are
-described in [modules/context-files](modules/context-files/README.md).
-
-**Prompts** are Markdown templates in the profile's `prompts/` and in trusted
-projects' `.agents/prompts` and `.claude/commands`. Each file is a command named
-after it; `/name text` sends the body with `$ARGUMENTS` replaced as a user message.
-See [modules/prompts](modules/prompts/README.md).
-
-**Hooks:** `chui hooks list` lists them and `chui hooks trust` approves command
-hooks. Desktop clients edit only `hooks.json` files; a handler saved there is
-approved, and handlers approved before stay so.
-
-### MCP
-
-MCP supports stdio and Streamable HTTP servers: tools, resources and
-elicitation. All of it goes through the permission gate.
-
-```toml
-[mcp_servers.local]
-command = "/path/to/server"
-args = []
-env_vars = ["SERVICE_TOKEN"]     # passed through; beyond HOME, PATH and a few basics, nothing else is
-
-[mcp_servers.remote]
-url = "https://mcp.example/mcp"
-tool_timeout_sec = 60
-```
-
-```sh
-chui mcp list
-chui mcp login remote [--scopes a,b]   # browser OAuth with PKCE and a loopback callback
-chui mcp logout remote
-```
-
-OAuth tokens are refreshed automatically and stored with mode 0600. Logout
-deletes the local token but does not revoke it on the server. A static header
-or `bearer_token_env_var` takes precedence over OAuth. See
-[modules/mcp](modules/mcp/README.md).
-
-## Sessions and diagnostics
-
-- **Sessions.** They are append-only JSONL trees with branches.
-  - Resuming restores messages and module state.
-  - It does not restore session grants or the side chat.
-  - The resume picker searches and previews. See [crates/tiechui-session](crates/tiechui-session/README.md).
-- **`chui doctor`.** It is read-only and exits nonzero when it finds a problem. It checks:
-  - installed binaries against the ownership record;
-  - interrupted installs;
-  - 0700 profile directories, and 0600 secret and token files and a
-    `providers.toml` that holds an inline key;
-  - config and grant shapes, and session versions.
-
-  It never opens secret or token files and never prints credentials. Use `--prefix` and `--profile` to point it
-  elsewhere. A binary built from source skips the install checks.
-
-## Develop
-
-You need:
-
-- Rust 1.95.0, Git, Python 3.10+ (standard library only), Node 25 (optional);
-- `just`, `cargo-nextest`, `cargo-deny`;
-- `rg` for content-search tests.
-
-Tests use no network and no real credentials.
-
-```sh
-cargo fetch --locked && cargo deny fetch    # once, before offline checks
-just check     # fmt, clippy, nextest, deny, schema and SDK drift, packaging tests
-just pty       # terminal emulator suite against a local mock provider
-just pty resume approval                    # selected PTY cases
-just plugins-check                          # validates ../tiechui-plugins when present
-```
-
-- Each part of `check` is its own recipe: `fmt`, `lint`, `test`, `deny`,
-  `schema-check`, `sdk-check` and `packaging-check`.
-- `just fmt` only checks; `cargo fmt --all` rewrites.
-- On a small disk, set `CARGO_INCREMENTAL=0`.
-- The PTY suite is described in [tests/pty](tests/pty/README.md).
-
-**CI** (`.github/workflows/ci.yml`) runs `just check` and `just pty` on Linux
-and macOS, and builds and runs the unit and doc tests on Windows.
-
-**Release** (`.github/workflows/release.yml`) runs on a `v*` tag that must match
-the workspace version:
-
-- it builds tarballs on native Linux x86_64 and aarch64 and macOS arm64 and x86_64 runners, and a zip for Windows x86_64;
-- it attaches them and a combined `SHA256SUMS` to a **draft** release, which you publish by hand;
-- the annotated tag message (`git tag -a v0.2.0 -F notes.md`) becomes the release notes;
-- publishing the release runs `.github/workflows/npm.yml`, which publishes `@tiechui/cli`.
-
-### Layout
-
-| Path | Role |
-| --- | --- |
-| `crates/tiechui-protocol`, `tiechui-model` | Protocol events and model types |
-| `crates/tiechui-core` | Session actor: turns, tool scheduling, retry, replay, module lifecycle |
-| `crates/tiechui-providers` | Anthropic and OpenAI-compatible wires |
-| `crates/tiechui-config`, `tiechui-session` | Typed config, JSONL session store |
-| `crates/tiechui-exec`, `tiechui-tools` | Process execution, built-in tools |
-| `crates/tiechui-tui`, `tiechui-cli` | Terminal UI (protocol only), CLI |
-| `crates/tiechui-plugin-api`, `tiechui-plugin-sdk`, `sdk/typescript` | Module API, plugin SDKs |
-| `modules/` | editing, exec, permissions, ask, hooks, context-files, skills, prompts, mcp, plugins, context, rewind, btw, goal, loop, compaction, subagents, tool-search, ptc |
-| `xtask/`, `scripts/`, `tests/` | Maintenance tasks, packaging, PTY tests |
-| `site/` | UI gallery rendered from the TUI snapshots |
-
-Features live in modules behind `tiechui-plugin-api`. The kernel carries no
-feature policy and the TUI depends only on the protocol. The session actor is
-described in [crates/tiechui-core](crates/tiechui-core/README.md).
-
-## Status
-
-Tiechui is young and changes quickly; config and session formats may still
-change before 1.0. Not yet supported:
-
-- an OS sandbox;
-- subscription logins;
-- `chui mcp serve`;
-- Homebrew.
-
-## License
-
-Tiechui is licensed under the [GNU Affero General Public License v3.0](LICENSE).
-Contributions are welcome; see [CONTRIBUTING.md](CONTRIBUTING.md).

package/bin/chui.js

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-// Runs the native build that the matching optional dependency installed.
-const { spawn } = require("child_process");
-const path = require("path");
-
-const PLATFORMS = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64"];
-const platform = `${process.platform}-${process.arch}`;
-
-let binary;
-try {
-  const root = path.dirname(require.resolve(`@tiechui/cli-${platform}/package.json`));
-  binary = path.join(root, process.platform === "win32" ? "chui.exe" : "chui");
-} catch {
-  console.error(
-    PLATFORMS.includes(platform)
-      ? `chui: the ${platform} build is missing; optional dependencies were probably skipped. Reinstall with one of:\n` +
-          "  npm i -g @tiechui/cli\n  pnpm add -g @tiechui/cli\n  yarn global add @tiechui/cli\n  bun add -g @tiechui/cli"
-      : `chui: no build for ${platform}; supported: ${PLATFORMS.join(", ")}`,
-  );
-  process.exit(1);
-}
-
-const child = spawn(binary, process.argv.slice(2), {
-  stdio: "inherit",
-  env: { ...process.env, TIECHUI_INSTALL: "npm" },
-});
-child.on("error", (error) => {
-  console.error(`chui: ${binary}: ${error.message}`);
-  process.exit(1);
-});
-// The terminal already sends Ctrl+C to chui, which reads a second one as "exit now".
-process.on("SIGINT", () => {});
-for (const signal of ["SIGTERM", "SIGHUP"]) {
-  process.on(signal, () => child.kill(signal));
-}
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.removeAllListeners(signal);
-    process.kill(process.pid, signal);
-  } else {
-    process.exit(code ?? 1);
-  }
-});