@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/tui/word-navigation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Options for word navigation functions.
+ * When omitted, uses the default Intl.Segmenter word segmentation.
+ */
+export interface WordNavigationOptions {
+    /** Custom segmenter returning word segments for the given text. */
+    segment?: (text: string) => Iterable<Intl.SegmentData>;
+    /** Predicate identifying atomic segments that should be treated as single units (e.g. paste markers). */
+    isAtomicSegment?: (segment: string) => boolean;
+}
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function andorraFindWordBackward(text: string, cursor: number, options?: WordNavigationOptions): number;
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function andorraFindWordForward(text: string, cursor: number, options?: WordNavigationOptions): number;

package/dist/vendor/engine/runtime/tui/word-navigation.js

@@ -0,0 +1,95 @@
+import { andorraGetWordSegmenter, andorraIsWhitespaceChar, PUNCTUATION_REGEX } from "./utils.js";
+const wordSegmenter = andorraGetWordSegmenter();
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function andorraFindWordBackward(text, cursor, options) {
+    if (cursor <= 0)
+        return 0;
+    const textBeforeCursor = text.slice(0, cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? [...segmentFn(textBeforeCursor)] : [...wordSegmenter.segment(textBeforeCursor)];
+    let newCursor = cursor;
+    // Skip trailing whitespace
+    while (segments.length > 0 &&
+        !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+        andorraIsWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+        newCursor -= segments.pop()?.segment.length || 0;
+    }
+    if (segments.length === 0)
+        return newCursor;
+    const last = segments[segments.length - 1];
+    if (isAtomic?.(last.segment)) {
+        // Skip one atomic segment.
+        newCursor -= last.segment.length;
+    }
+    else if (last.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        const segment = last.segment;
+        const matches = [...segment.matchAll(new RegExp(PUNCTUATION_REGEX, "g"))];
+        if (matches.length <= 0) {
+            newCursor -= segment.length;
+        }
+        else {
+            const lastMatch = matches[matches.length - 1];
+            newCursor -= segment.length - (lastMatch.index + lastMatch[0].length);
+        }
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (segments.length > 0 &&
+            !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+            !segments[segments.length - 1]?.isWordLike &&
+            !andorraIsWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+            newCursor -= segments.pop()?.segment.length || 0;
+        }
+    }
+    return newCursor;
+}
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function andorraFindWordForward(text, cursor, options) {
+    if (cursor >= text.length)
+        return text.length;
+    const textAfterCursor = text.slice(cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? segmentFn(textAfterCursor) : wordSegmenter.segment(textAfterCursor);
+    const iterator = segments[Symbol.iterator]();
+    let next = iterator.next();
+    let newCursor = cursor;
+    // Skip leading whitespace
+    while (!next.done && !isAtomic?.(next.value.segment) && andorraIsWhitespaceChar(next.value.segment)) {
+        newCursor += next.value.segment.length;
+        next = iterator.next();
+    }
+    if (next.done)
+        return newCursor;
+    if (isAtomic?.(next.value.segment)) {
+        // Skip one atomic segment.
+        newCursor += next.value.segment.length;
+    }
+    else if (next.value.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        newCursor += PUNCTUATION_REGEX.exec(next.value.segment)?.index ?? next.value.segment.length;
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (!next.done &&
+            !isAtomic?.(next.value.segment) &&
+            !next.value.isWordLike &&
+            !andorraIsWhitespaceChar(next.value.segment)) {
+            newCursor += next.value.segment.length;
+            next = iterator.next();
+        }
+    }
+    return newCursor;
+}

package/dist/vendor/zcode/LICENSE.upstream

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Z.AI Co., Ltd
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/vendor/zcode/provenance.json

@@ -0,0 +1,141 @@
+{
+  "project": "https://github.com/zai-org/ZCode",
+  "revision": "29628c9acdb81b703bbd4080c207a0e7ce5e276e",
+  "license": "Apache-2.0",
+  "copyright": "Copyright 2026 Z.AI Co., Ltd.",
+  "files": [
+    {
+      "path": "vendor/zcode/source/agent/turn-machine.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/agent/turn-machine.ts",
+      "upstreamSha256": "3efcc234b74d3e7668ad370b0b66b23709fb25249c98a5b91aa48a5d64b7d5dd",
+      "adaptedSha256": "f177e4c3cd9be86e4e573497946558c60ee7acc2c780f92af3f3d7694c8237ad",
+      "modifications": "Local contracts import shim"
+    },
+    {
+      "path": "vendor/zcode/source/agent/turn-state.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/agent/turn-state.ts",
+      "upstreamSha256": "98dd0585203eccb5723ef0e51930e8c88cc7ceb1a930fca51ca63297151614ac",
+      "adaptedSha256": "62c91f9dd42117347e3f9172c7119c970caa967e7f42726e00a8f6c3e7275e14",
+      "modifications": "Local contracts import shim"
+    },
+    {
+      "path": "vendor/zcode/source/compact/manual.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/compact/manual.ts",
+      "upstreamSha256": "49e96f7f450ee324e6baa05997856601a0f998cda835321c57c31f9eda3a0c34",
+      "adaptedSha256": "64d077a1b223d2d89a4abb8c9d5a2c234e3af1073750c81f5959aac3d170df03",
+      "modifications": "Dependency-isolated typed Andorra host ports / selected upstream algorithm; see docs/zcode-engine.md"
+    },
+    {
+      "path": "vendor/zcode/source/compact/microcompact.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/compact/microcompact.ts",
+      "upstreamSha256": "d8b7880479235b95683dddf1a30ee383d43428a4ec758d288d0e47a3cdd8bc6f",
+      "adaptedSha256": "1b31cfe76233de13dd0f9baef7d09b417b2df2d437251fc86520aab6988e53ef",
+      "modifications": "Local contracts import shim"
+    },
+    {
+      "path": "vendor/zcode/source/compact/policy.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/compact/policy.ts",
+      "upstreamSha256": "b58b2fccdd3252aeff356f918c0591bda94b3263fb83451083e1e00d0e17ad91",
+      "adaptedSha256": "9206ca22a42ac24158863fff2d5e571a79061a8622b28bf6ab165e9e26a43526",
+      "modifications": "Dependency-isolated typed Andorra host ports / selected upstream algorithm; see docs/zcode-engine.md"
+    },
+    {
+      "path": "vendor/zcode/source/compact/selection.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/runtime/helpers/compact-selection.ts",
+      "upstreamSha256": "61b974779f6cafc902effb71d6f920671fab5aaa449afc6939436f1b3ba60d5b",
+      "adaptedSha256": "2ed91990522d7061b744a12aa35a7a624e2e06dacedb719fc2731d5049069c08",
+      "modifications": "Dependency-isolated typed Andorra host ports / selected upstream algorithm; see docs/zcode-engine.md"
+    },
+    {
+      "path": "vendor/zcode/source/contracts.ts",
+      "upstreamPath": null,
+      "upstreamSha256": null,
+      "adaptedSha256": "532f4d40f386e9faf8bca3296f0f4dfb1ce4e9781ed33d8995ae5a330a65c18f",
+      "modifications": "Dependency-isolated typed Andorra host ports / selected upstream algorithm; see docs/zcode-engine.md"
+    },
+    {
+      "path": "vendor/zcode/source/runtime/turn-loop.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/runtime/methods/turn-loop.ts",
+      "upstreamSha256": "a038a72d010fe20b0f5d015642e6f5b78804c929f286d65bb1bdaa367765b84e",
+      "adaptedSha256": "8113739f2bddfd56aa9ab80ebc8f8065c296d78620c95c76cc335e272d24b0b7",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/runtime/turn-model-step.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/runtime/methods/turn-model-step.ts",
+      "upstreamSha256": "db42add545d11b4c5c63bcf393c9e47a278a36cf37fa2f99a003430fbd960e96",
+      "adaptedSha256": "9b581fa545b0e7f2d256b0cc80e8ebe07fb3c9884429fd36d1ef4a8be44506e3",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/scheduler.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/scheduler.ts",
+      "upstreamSha256": "590fb51cd590d9daa131c2522b1ad22933bdc61d6bedcc35cf8a8ffd6682c9f6",
+      "adaptedSha256": "ef47a7acda37d01d28448aebfa5e48abfb897da8f6734295b74b706fd2af1a24",
+      "modifications": "Local contracts import shim"
+    },
+    {
+      "path": "vendor/zcode/source/runtime/turn-output-token-continuation.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/runtime/methods/turn-output-token-continuation.ts",
+      "upstreamSha256": "23ca9cc85d13499e3bf48f4000b0d04db0d182455521408b2665a1dcf28d78ca",
+      "adaptedSha256": "bee2848f905b8599cb81ce455072a903b0502a621b9c14319d3fe0a48f160c21",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/runtime/turn-stop.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/runtime/methods/turn-stop.ts",
+      "upstreamSha256": "2c78a85bc97f69a81d3c0a7bbbc184498a2d2d4609129dbf933678f7747b322c",
+      "adaptedSha256": "d71b378379ba2f2ff48a012d4d9b091a70b11257d3958781a83eb2be601c9990",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/input-normalization.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/input-normalization.ts",
+      "upstreamSha256": "c36dddc4a4a8abbab1eca78ad866c9a338eafe41af4a441782e5c441656c4cf5",
+      "adaptedSha256": "0f7b8c782025bdda83d768a6fed0ef64dfa62354e3df4cd98808f060ce1ee895",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/input-validation-model-content.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/input-validation-model-content.ts",
+      "upstreamSha256": "6bf5572e9a4253f7c2670b77418a788db1784f4eb027ef2b017e2511cdf748fb",
+      "adaptedSha256": "694eaeb253f752b0eef7701533a0896992d37a31a7f6bc7a03038993623ee1c0",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/json-schema.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/json-schema.ts",
+      "upstreamSha256": "d117a24bbb3808f1a7fbb2564d4f00eb6091ef3bc28378647633c83fe2fe87af",
+      "adaptedSha256": "185a8b35276cf45047128542c5fb27d77a4418c36deac1701b94e294927f13b5",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/tool-input-validation-issues.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/tool-input-validation-issues.ts",
+      "upstreamSha256": "f25da6f6c8da4e6c922b7b837b4f55556610eb47f5b14256be812eaea52131dd",
+      "adaptedSha256": "936733ba509c7abfac019a7171a73027989926f655b6e37a5c8299335ea95969",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/validation-contracts.ts",
+      "upstreamPath": null,
+      "upstreamSha256": null,
+      "adaptedSha256": "31c3b66961454c87517092a2316e6ccd2ed6f54c16a00fe062595e7c8e95a47b",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/tool/executor/validation.ts",
+      "upstreamPath": "apps/zcode-cli/packages/core/src/tool/executor/validation.ts",
+      "upstreamSha256": "d32cd4312562977d10b903b61110c6d017fb7cc57f8f318d369bcdc7fab6229f",
+      "adaptedSha256": "c9e90c1d270c4cf5c18183d3a69f36227fbbb2073cb7361eea7e22106a4fd057",
+      "modifications": "Typed host ports preserve graph permissions and persistence; native stop ordering, output continuation and JSON schema semantics. See docs/zcode-engine.md for deliberate boundaries."
+    },
+    {
+      "path": "vendor/zcode/source/runtime/goal-completion-verification.ts",
+      "upstreamPath": "apps/zcode-cli/packages/contracts/src/tools/target.ts",
+      "upstreamSha256": "e1cd8c69339cb30642bec1ee0b508e24fe1a9c7778db8c3d23e6e2489ac9db1e",
+      "modifications": "Selected native goal prompt/parser with explicit fail-closed structured verifier adapter.",
+      "adaptedSha256": "2348c199223e3cbd42f997a35209cdb7e19785f0afd2b678a6c5a455c30886d1"
+    }
+  ]
+}

package/dist/vendor/zcode/source/agent/turn-machine.d.ts

@@ -0,0 +1,56 @@
+import type { TurnState, TurnPhase, ToolCall, ToolScheduleState, PermissionRequestState, PermissionDecision, TurnResultType, TurnErrorState, ModelRequestState } from "./turn-state.js";
+import type { ModelMessageContent, SessionId, TraceId, ToolCallId, TurnId } from "../contracts.js";
+import type { PendingTurnInput } from "../contracts.js";
+export interface TurnMachine {
+    state: TurnState;
+    start(): TurnState;
+    startModelRequest(model: string, messages: ModelRequestState["messages"]): TurnState;
+    receiveModelResponse(content: string): TurnState;
+    addStreamingContent(content: string): TurnState;
+    scheduleTools(toolCalls: ToolCall[], schedule: ToolScheduleState): TurnState;
+    startToolExecution(): TurnState;
+    completeTool(toolCallId: ToolCallId, result: {
+        success: boolean;
+        content: ModelMessageContent;
+    }): TurnState;
+    queuePendingInput(input: PendingTurnInput): TurnState;
+    drainPendingInputs(): {
+        inputs: PendingTurnInput[];
+        state: TurnState;
+    };
+    requestPermission(request: PermissionRequestState): TurnState;
+    resolvePermission(toolCallId: ToolCallId, decision: PermissionDecision, modifiedInput?: unknown): TurnState;
+    aggregateResults(): TurnState;
+    complete(response: string, resultType?: TurnResultType): TurnState;
+    fail(error: TurnErrorState): TurnState;
+    getNextPhase(): TurnPhase;
+    isComplete(): boolean;
+}
+export declare class TurnMachineImpl implements TurnMachine {
+    state: TurnState;
+    constructor(state: TurnState);
+    static create(sessionId: SessionId, turnNumber: number, input: string, traceId?: TraceId, turnId?: TurnId): TurnMachineImpl;
+    private transition;
+    start(): TurnState;
+    startModelRequest(model: string, messages: ModelRequestState["messages"]): TurnState;
+    receiveModelResponse(content: string): TurnState;
+    addStreamingContent(content: string): TurnState;
+    scheduleTools(toolCalls: ToolCall[], schedule: ToolScheduleState): TurnState;
+    startToolExecution(): TurnState;
+    completeTool(toolCallId: ToolCallId, result: {
+        success: boolean;
+        content: ModelMessageContent;
+    }): TurnState;
+    queuePendingInput(input: PendingTurnInput): TurnState;
+    drainPendingInputs(): {
+        inputs: PendingTurnInput[];
+        state: TurnState;
+    };
+    requestPermission(request: PermissionRequestState): TurnState;
+    resolvePermission(toolCallId: ToolCallId, decision: PermissionDecision, modifiedInput?: unknown): TurnState;
+    aggregateResults(): TurnState;
+    complete(response: string, resultType?: TurnResultType): TurnState;
+    fail(error: TurnErrorState): TurnState;
+    getNextPhase(): TurnPhase;
+    isComplete(): boolean;
+}