@crewhaus/tool-plan 0.7.0 → 0.8.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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 [yyyy] [name of copyright owner]
+
+   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/NOTICE

@@ -0,0 +1,9 @@
+CrewHaus Factory
+Copyright 2026 Max Meier
+
+This product includes software developed by Max Meier
+(operating as StudioMax — https://studiomax.io) and contributors.
+
+The CrewHaus name and logo are trademarks of Max Meier. See
+https://github.com/crewhaus/factory/blob/main/TRADEMARK.md for the
+use-of-marks policy.

package/README.md

@@ -12,6 +12,7 @@ import { defaultCatalog } from "@crewhaus/tool-catalog";
 const bundle = createPlanTools({
   specName: "support-bot",
   appendEvent: (e) => eventLog.append(e), // plan_update / goal_update / action_proof
+  proofMode: "ladder", // continuity.proof — "ladder" (default) | "require" | "off"
 });
 for (const tool of bundle.all) defaultCatalog.register(tool);
 ```
@@ -24,7 +25,7 @@ for (const tool of bundle.all) defaultCatalog.register(tool);
 | `FocusWrite` | destructive (audit-and-allow, **no** justification — it's the hot loop) | Replace the focus body (capped at `focusMaxChars`) |
 | `PlanRead` | readOnly | Numbered steps with ladder statuses; `claimed` rendered as unverified |
 | `PlanUpdate` | destructive (audit-and-allow) | `create` / `add_step` / `set_step_status` (up to `claimed`) / `set_active` |
-| `PlanComplete` | destructive | The **proven** transition: requires `evidence: [{toolUseId}]`, machine-checked against session event logs (child sessions included) |
+| `PlanComplete` | destructive | The **proven** transition: requires `evidence: [{toolUseId}]`, machine-checked against session event logs (child sessions included); recorded unchecked under `continuity.proof: off` |
 | `GoalWrite` | destructive | Create a goal (`goals.yaml`) |
 | `GoalUpdate` | destructive | Update a goal; `proven` requires evidence like a step |
 | `GoalList` | readOnly | List goals with progress |
@@ -35,6 +36,72 @@ rejects with `no verified evidence for tu_…: run the action first, then
 complete the step with its toolUseId.` — the *bias toward action*: narration
 can never produce a ✓.
 
+## Proof modes (`continuity.proof`)
+
+`createPlanTools({ proofMode })` takes the spec's `continuity.proof`, which
+memory-service passes through. The modes are enforced since 0.8.0
+(design/0.8.0-provability-release.md §6.3); before that, `require` and `off`
+ran the ladder and printed a boot note.
+
+| Mode | `claimed` | `proven` | Completion below `proven` |
+| --- | --- | --- | --- |
+| `ladder` (default) | free | evidence verified against the session event log | — (the pre-0.8.0 proof behaviour and tool descriptions) |
+| `require` | free — honest progress | verified, exactly as `ladder` | refused, with an error that teaches the proof |
+| `off` | free | the cited toolUseIds are **recorded, not resolved** | — |
+
+**`require`.** Nothing below `proven` completes anything. Plans have no
+close operation: a plan is complete exactly when every step is proven, so a
+claimed step leaves it open. Once nothing is left open or in progress, the
+`PlanUpdate` and `PlanComplete` replies name the steps that still need proof
+(`plan-0001 is not complete: step 3 is claimed, not proven — prove it with
+PlanComplete({step, evidence: [{toolUseId}]}) first.`). The one way the
+store could mark something achieved below `proven` is a goal's progress
+(`current`, read as 0 when unset) reaching its `target`, which is how the
+Thredz mirror completes a goal. So `GoalWrite` refuses a goal created at its
+target (a `target: 0` goal included), and `GoalUpdate` refuses progress that
+reaches it unless the same call proves the goal (`status: "proven"` with
+evidence). `GoalUpdate`'s check runs inside the store lock on the record as
+written, so two sessions cannot each pass it on a stale read. The tool
+descriptions under `require` say that only a proven step or goal is done.
+
+Two kinds of `proven` record count as below `proven` under `require` until a
+verified proof replaces them: one proven by assertion in an earlier `off`
+run, and one with no frozen proof at all. The store never writes the
+second, so it is a hand edit, or a step line that a multi-line plan title
+smuggled into a plan file before titles were kept to one line. Every surface
+counts them the way the tools do (continuity-store's `countsAsProven`): such
+a goal stays among the open goals in the `<current_plan>` tail and in
+`handoff.md`, such a step of the active plan is named in the handoff's Next
+actions as `Prove: …`, another plan holding one stays among the handoff's
+open plans with the step left out of its proven count, and the Thredz goal
+mirror does not complete the remote goal.
+`createPlanTools` passes its `proofMode` to the store it builds, so that
+store's handoff agrees with the tools.
+
+**`off`** is for harnesses that keep **no session event log**, so there is
+nothing to resolve a toolUseId against. `PlanComplete` and
+`GoalUpdate({status: "proven"})` still require cited evidence, but record it
+as unverified refs (never as frozen proofs) and pin no session for
+retention. Each cited id must be one token (letters, digits, `_ . : -`, at
+most 256 characters), and a record holds at most 32, so a citation cannot
+inject a forged line into a render or inflate a state file. `PlanRead`,
+`GoalList`, the `<current_plan>` tail and `handoff.md` show
+`[proven (unverified)]`, never `[proven]`. A step already proven with
+verified evidence keeps its ✓: an unverified proof never downgrades it.
+
+**One line per record, in every mode** (0.8.0, the default `ladder`
+included). A plan or goal title, and a goal unit, is stored as one line:
+every whitespace run, newlines included, collapses to one space and the ends
+are trimmed, as step text always was. A title over 512 characters
+(`MAX_TITLE_CHARS`) or a unit over 64 (`MAX_UNIT_CHARS`) is refused with
+nothing written. Before 0.8.0 a title was only trimmed and a unit kept as
+given, so a multi-line title could carry a forged `[proven]` step line into
+a plan file. The default mode can therefore refuse a `PlanUpdate`,
+`GoalWrite` or `GoalUpdate` it accepted before (an oversized title or unit,
+or a `GoalUpdate` title that is only whitespace, as a new title already
+could not be), and a multi-line title now reads back on one line. See
+continuity-store's "One line per record".
+
 ## Event emission (decoupled)
 
 Mutations emit the additive event-log kinds `plan_update`, `goal_update`, and
@@ -42,7 +109,10 @@ Mutations emit the additive event-log kinds `plan_update`, `goal_update`, and
 `appendEvent` callback — this package never imports runtime wiring; emitters
 or memory-service decide where events land (session JSONL, trace bus, both).
 Rejected proof attempts emit `action_proof` too (`missing` / `error_result`),
-so the audit trail records proof pressure, not just wins.
+so the audit trail records proof pressure, not just wins; under
+`proofMode: "off"` the verdict is `unverified` — recorded, never checked —
+and a goal proven that way says `verification: "unverified"` on its
+`goal_update`.
 
 ## Pillar 3 notes
 

package/dist/index.d.ts

@@ -31,6 +31,52 @@
  * Rejected proof attempts emit `action_proof` too (verdict `missing` /
  * `error_result`): the audit trail records proof pressure, not just wins.
  *
+ * Proof modes (`continuity.proof`, design §2.4; enforced from 0.8.0,
+ * design/0.8.0-provability-release.md §6.3) — `createPlanTools({proofMode})`:
+ *
+ *   ladder  (default) the proof behaviour above, unchanged from before
+ *           0.8.0: `claimed` is free, `proven` needs verified evidence, and
+ *           the tool descriptions are the pre-0.8.0 strings.
+ *   require the ladder, plus: nothing below `proven` COMPLETES anything.
+ *           `claimed` stays settable — it is honest progress — but the
+ *           tools refuse every operation that would mark a goal achieved
+ *           while it is below `proven`. The store has exactly one such
+ *           path: a goal whose progress (`current`, 0 when unset) reaches
+ *           its `target` (the Thredz mirror completes a goal on
+ *           `currentValue >= targetValue`), so GoalWrite/GoalUpdate refuse
+ *           that unless the same call proves the goal — GoalUpdate through
+ *           a store guard evaluated under the store lock, so concurrent
+ *           sessions cannot each pass a stale check. Plans have no close
+ *           operation: a plan is complete exactly when every step is
+ *           proven, which only PlanComplete's verified path reaches — so a
+ *           claimed step leaves the plan open, and the tools say which
+ *           steps still need proof. A record proven by assertion under an
+ *           earlier `off` run counts as below `proven` here, and so does a
+ *           `proven` record with no frozen proof (the store never writes one;
+ *           see `verifiedProven`). The `<current_plan>` tail, handoff.md and
+ *           the Thredz goal mirror count such a record the same way
+ *           (continuity-store's `countsAsProven`): open, and not completed.
+ *   off     no verification, for harnesses that keep no session event log
+ *           to resolve evidence against. PlanComplete / GoalUpdate `proven`
+ *           still demand cited toolUseIds (one token each, see the store's
+ *           `UNVERIFIED_TOOL_USE_ID_REGEX`), record them as UNVERIFIED refs
+ *           (never frozen proofs) and pin no session for retention.
+ *           PlanComplete emits `action_proof` with `verdict: "unverified"`;
+ *           GoalUpdate marks its `goal_update` `verification: "unverified"`
+ *           (`action_proof` is keyed by plan step). Every tool render says
+ *           `[proven (unverified)]`, never `[proven]`.
+ *
+ * In EVERY mode, the ladder included (0.8.0, continuity-store's "one line
+ * per record"): a plan or goal title, and a goal unit, is stored as one line
+ * — every whitespace run, newlines included, collapses to one space and the
+ * ends are trimmed, as step text always was — and a title over 512
+ * characters (`MAX_TITLE_CHARS`) or a unit over 64 (`MAX_UNIT_CHARS`) is
+ * refused with nothing written. Before 0.8.0 the store only trimmed a title
+ * and kept a unit as given, so a multi-line title could carry a forged
+ * `[proven]` step line into a plan file, which defeated `require`. These caps, and a GoalUpdate title
+ * that is only whitespace (refused as GoalWrite's and PlanUpdate's always
+ * were), are the input the default mode now refuses that it used to accept.
+ *
  * Pillar 3: plan/focus/ledger content is user-authored working state
  * (origin "user" semantics, like tool-memory writes) — recalled wiki/fact
  * content is what gets the new `memory` TrustOrigin, not this. All tools are
@@ -70,6 +116,22 @@ export type AppendContinuityEvent = (event: ContinuityEvent) => void | Promise<v
  * → tail re-render), so a drift in either literal fails tests.
  */
 export declare const PLAN_DIRTY_STATE_KEY = "plan.dirty";
+/**
+ * `continuity.proof` (design §2.4, enforced from design/0.8.0 §6.3) — how the
+ * tools treat the `proven` rung. See the module docblock for each mode.
+ */
+export type ProofMode = "ladder" | "require" | "off";
+export declare const PROOF_MODES: readonly ProofMode[];
+/** The lowered default, and the only behaviour before 0.8.0. */
+export declare const DEFAULT_PROOF_MODE: ProofMode;
+/**
+ * Thrown under `proofMode: "require"` by an operation that would complete
+ * something below `proven`. The message teaches the proven path — the
+ * model's next call should be the proof, not a retry of the same claim.
+ */
+export declare class ProofRequiredError extends Error {
+    readonly name = "ProofRequiredError";
+}
 export type CreatePlanToolsOptions = {
     readonly specName: string;
     readonly rootDir?: string;
@@ -84,6 +146,8 @@ export type CreatePlanToolsOptions = {
     /** Event-log append seam — see `AppendContinuityEvent`. */
     readonly appendEvent?: AppendContinuityEvent;
     readonly now?: () => Date;
+    /** `continuity.proof` — default {@link DEFAULT_PROOF_MODE} (`"ladder"`). */
+    readonly proofMode?: ProofMode;
 };
 export type PlanToolBundle = {
     readonly focusRead: RegisteredTool;

package/dist/index.js

@@ -31,12 +31,58 @@
  * Rejected proof attempts emit `action_proof` too (verdict `missing` /
  * `error_result`): the audit trail records proof pressure, not just wins.
  *
+ * Proof modes (`continuity.proof`, design §2.4; enforced from 0.8.0,
+ * design/0.8.0-provability-release.md §6.3) — `createPlanTools({proofMode})`:
+ *
+ *   ladder  (default) the proof behaviour above, unchanged from before
+ *           0.8.0: `claimed` is free, `proven` needs verified evidence, and
+ *           the tool descriptions are the pre-0.8.0 strings.
+ *   require the ladder, plus: nothing below `proven` COMPLETES anything.
+ *           `claimed` stays settable — it is honest progress — but the
+ *           tools refuse every operation that would mark a goal achieved
+ *           while it is below `proven`. The store has exactly one such
+ *           path: a goal whose progress (`current`, 0 when unset) reaches
+ *           its `target` (the Thredz mirror completes a goal on
+ *           `currentValue >= targetValue`), so GoalWrite/GoalUpdate refuse
+ *           that unless the same call proves the goal — GoalUpdate through
+ *           a store guard evaluated under the store lock, so concurrent
+ *           sessions cannot each pass a stale check. Plans have no close
+ *           operation: a plan is complete exactly when every step is
+ *           proven, which only PlanComplete's verified path reaches — so a
+ *           claimed step leaves the plan open, and the tools say which
+ *           steps still need proof. A record proven by assertion under an
+ *           earlier `off` run counts as below `proven` here, and so does a
+ *           `proven` record with no frozen proof (the store never writes one;
+ *           see `verifiedProven`). The `<current_plan>` tail, handoff.md and
+ *           the Thredz goal mirror count such a record the same way
+ *           (continuity-store's `countsAsProven`): open, and not completed.
+ *   off     no verification, for harnesses that keep no session event log
+ *           to resolve evidence against. PlanComplete / GoalUpdate `proven`
+ *           still demand cited toolUseIds (one token each, see the store's
+ *           `UNVERIFIED_TOOL_USE_ID_REGEX`), record them as UNVERIFIED refs
+ *           (never frozen proofs) and pin no session for retention.
+ *           PlanComplete emits `action_proof` with `verdict: "unverified"`;
+ *           GoalUpdate marks its `goal_update` `verification: "unverified"`
+ *           (`action_proof` is keyed by plan step). Every tool render says
+ *           `[proven (unverified)]`, never `[proven]`.
+ *
+ * In EVERY mode, the ladder included (0.8.0, continuity-store's "one line
+ * per record"): a plan or goal title, and a goal unit, is stored as one line
+ * — every whitespace run, newlines included, collapses to one space and the
+ * ends are trimmed, as step text always was — and a title over 512
+ * characters (`MAX_TITLE_CHARS`) or a unit over 64 (`MAX_UNIT_CHARS`) is
+ * refused with nothing written. Before 0.8.0 the store only trimmed a title
+ * and kept a unit as given, so a multi-line title could carry a forged
+ * `[proven]` step line into a plan file, which defeated `require`. These caps, and a GoalUpdate title
+ * that is only whitespace (refused as GoalWrite's and PlanUpdate's always
+ * were), are the input the default mode now refuses that it used to accept.
+ *
  * Pillar 3: plan/focus/ledger content is user-authored working state
  * (origin "user" semantics, like tool-memory writes) — recalled wiki/fact
  * content is what gets the new `memory` TrustOrigin, not this. All tools are
  * `scope: "internal"` (process-local files only).
  */
-import { EvidenceError, createContinuityStore, renderStatus, } from "@crewhaus/continuity-store";
+import { EvidenceError, createContinuityStore, isProvenByAssertion, isProvenVerified, renderLadderStatus, renderUnverifiedRef, } from "@crewhaus/continuity-store";
 import { formatAgentIdentity } from "@crewhaus/run-context";
 import { buildTool } from "@crewhaus/tool-builder";
 import { z } from "zod";
@@ -51,6 +97,17 @@ import { z } from "zod";
  * → tail re-render), so a drift in either literal fails tests.
  */
 export const PLAN_DIRTY_STATE_KEY = "plan.dirty";
+export const PROOF_MODES = ["ladder", "require", "off"];
+/** The lowered default, and the only behaviour before 0.8.0. */
+export const DEFAULT_PROOF_MODE = "ladder";
+/**
+ * Thrown under `proofMode: "require"` by an operation that would complete
+ * something below `proven`. The message teaches the proven path — the
+ * model's next call should be the proof, not a retry of the same claim.
+ */
+export class ProofRequiredError extends Error {
+    name = "ProofRequiredError";
+}
 // ---------------------------------------------------------------------------
 // schemas
 // ---------------------------------------------------------------------------
@@ -151,22 +208,152 @@ function renderPlan(plan) {
         lines.push("  (no steps yet — add some with PlanUpdate {action: 'add_step'})");
     }
     for (const step of plan.steps) {
-        const proofSuffix = step.status === "proven" && step.proofs.length > 0
-            ? ` — proof: ${step.proofs.map((p) => p.toolUseId).join(", ")}`
-            : "";
-        lines.push(`  ${step.index}. ${renderStatus(step.status)} ${step.text}${proofSuffix}`);
+        const proofSuffix = isProvenByAssertion(step)
+            ? ` — cited, not verified: ${(step.unverified ?? []).map((r) => r.toolUseId).join(", ")}`
+            : step.status === "proven" && step.proofs.length > 0
+                ? ` — proof: ${step.proofs.map((p) => p.toolUseId).join(", ")}`
+                : "";
+        lines.push(`  ${step.index}. ${renderLadderStatus(step)} ${step.text}${proofSuffix}`);
     }
     return lines.join("\n");
 }
-function renderGoal(goal) {
-    const progress = goal.target !== undefined
+function progressOf(goal) {
+    return goal.target !== undefined
         ? ` (${goal.current ?? 0}/${goal.target}${goal.unit !== undefined ? ` ${goal.unit}` : ""})`
         : "";
-    return `- ${goal.id} ${renderStatus(goal.status)} ${goal.title}${progress}`;
+}
+function renderGoal(goal) {
+    return `- ${goal.id} ${renderLadderStatus(goal)} ${goal.title}${progressOf(goal)}`;
+}
+/**
+ * The `require`-mode reading of "achieved": progress at or past the target,
+ * with an unset `current` read as 0. That is how every surface shows a goal
+ * (`progressOf`, the handoff, the `<current_plan>` tail all print
+ * `current ?? 0`), and it is the Thredz goal mirror's completion rule
+ * (`currentValue >= targetValue`, `currentValue` defaulting to 0). So a
+ * `target: 0` goal is achieved the moment it exists.
+ */
+function atTarget(goal) {
+    return goal.target !== undefined && (goal.current ?? 0) >= goal.target;
+}
+/** The `require` label for a `proven` record with no frozen proof. */
+const NO_PROOF_LABEL = "marked proven with no proof on record";
+/**
+ * `proven` with machine-checked evidence on record (the store's
+ * `isProvenVerified`). Under `require`, two kinds of `proven` record are
+ * below this, and complete nothing until a verified proof replaces them: one
+ * proven by assertion (an earlier `off` run), and one with no frozen proof at
+ * all. The store never writes the second — every verified transition freezes
+ * at least one proof — so it was edited into a file by hand, or read back
+ * from a step line that a multi-line plan title smuggled into a plan file
+ * before the store kept titles to one line. Nobody checked either.
+ */
+function verifiedProven(record) {
+    return isProvenVerified(record);
+}
+/** How a below-proven record names itself in a `require` refusal. */
+function belowProvenLabel(record) {
+    if (isProvenByAssertion(record))
+        return "proven (unverified)";
+    return record.status === "proven" ? NO_PROOF_LABEL : record.status;
+}
+/** `a`, `a or b`, `a, b or c`. */
+function orList(items) {
+    return items.length > 2
+        ? `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`
+        : items.join(" or ");
+}
+/**
+ * Under `require`, the note a plan earns once nothing is left open or in
+ * progress while some step is still below proven: claimed, proven by
+ * assertion under an earlier `off` run, or marked proven with no proof on
+ * record (see {@link verifiedProven}). That is the moment a model is
+ * likeliest to believe the plan is done, and it is not: each such step still
+ * needs a verified proof. Null while the plan still has unstarted work (the
+ * claim is then plainly not the end) or once every step is proven.
+ */
+function incompletePlanNote(plan) {
+    if (plan.steps.some((s) => s.status === "open" || s.status === "in_progress"))
+        return null;
+    const below = plan.steps.filter((s) => !verifiedProven(s));
+    if (below.length === 0)
+        return null;
+    const present = new Set(below.map(belowProvenLabel));
+    const labels = orList(["claimed", "proven (unverified)", NO_PROOF_LABEL].filter((l) => present.has(l)));
+    const which = below.length === 1
+        ? `step ${below[0]?.index} is ${labels}, not proven — prove it`
+        : `steps ${below.map((s) => s.index).join(", ")} are ${labels}, not proven — prove each`;
+    return `${plan.id} is not complete: ${which} with PlanComplete({step, evidence: [{toolUseId}]}) first.`;
+}
+/**
+ * The `require` refusal for a GoalWrite that would create a goal already at
+ * its target, or null when the goal starts below it.
+ */
+function goalWriteRefusal(input) {
+    if (input.target === undefined || !atTarget(input))
+        return null;
+    const progress = `${input.current ?? 0}/${input.target}${input.unit !== undefined ? ` ${input.unit}` : ""}`;
+    const head = `a new goal cannot start at its target (${progress}) under continuity.proof: require — that would mark it achieved without proof.`;
+    if (input.target > 0) {
+        return `${head} Create it without current (or below the target), then prove it with GoalUpdate({goalId, current: ${input.current}, status: "proven", evidence: [{toolUseId}]}).`;
+    }
+    // A target of 0 or below is met before any work: progress counts up from
+    // `current`, which reads as 0 when unset. Leaving out `current` cannot help.
+    return `${head} Progress counts up from current (0 when unset), so a target of ${input.target} is met before any work. Count up toward a positive target instead (for example, items done out of a total), or create the goal without a target and set it in the GoalUpdate that proves it: GoalUpdate({goalId, target: ${input.target}, status: "proven", evidence: [{toolUseId}]}).`;
+}
+/**
+ * The `require` refusal for a GoalUpdate whose RESULT (`next`, the record
+ * as written) sits at its target below a verified proof, or null. `input`
+ * supplies the fields the reply tells the model to resend with its proof.
+ */
+function goalUpdateRefusal(goalId, input, next) {
+    if (!atTarget(next) || verifiedProven(next))
+        return null;
+    const fields = [
+        ...(input.current !== undefined ? [`current: ${input.current}`] : []),
+        ...(input.target !== undefined ? [`target: ${input.target}`] : []),
+    ].join(", ");
+    const why = isProvenByAssertion(next)
+        ? `${goalId} is proven (unverified), which under continuity.proof: require is not proven — reaching its target${progressOf(next)} would mark it achieved. Prove it again in the same call, with verified evidence`
+        : `${goalId} is ${belowProvenLabel(next)}, not proven — reaching its target${progressOf(next)} would mark it achieved. Prove it in the same call`;
+    return `${why}: GoalUpdate({goalId: "${goalId}", ${fields}, status: "proven", evidence: [{toolUseId}]}), citing the call that measured it.`;
 }
 function renderRequirement(req) {
     return `- ${req.id} [${req.status}] ${JSON.stringify(req.text)} (user, ${req.source.sessionId}, turn ${req.source.turn})`;
 }
+// ---------------------------------------------------------------------------
+// per-mode descriptions — the ladder strings are the pre-0.8.0 bytes
+// ---------------------------------------------------------------------------
+const PLAN_READ_DESCRIPTION = {
+    ladder: "Read a plan's numbered steps with their proof-ladder statuses. 'claimed' steps are rendered as unverified — only 'proven' steps have machine-checked evidence. Omit planId for the active plan.",
+    require: "Read a plan's numbered steps with their proof-ladder statuses. 'claimed' steps are rendered as unverified — only 'proven' steps have machine-checked evidence, and a plan is complete only when every step is proven. Omit planId for the active plan.",
+    off: "Read a plan's numbered steps with their proof-ladder statuses. Proof checking is off in this harness: 'claimed' and 'proven (unverified)' steps are both the model's own account, and nothing is machine-checked. Omit planId for the active plan.",
+};
+const PLAN_UPDATE_DESCRIPTION = {
+    ladder: "Mutate the persisted plan: create a plan, add a step, move a step's ladder status (open → in_progress → claimed), or set the active plan. 'claimed' records progress WITHOUT verification — the 'proven' transition goes through PlanComplete with evidence.",
+    require: "Mutate the persisted plan: create a plan, add a step, move a step's ladder status (open → in_progress → claimed), or set the active plan. 'claimed' records progress WITHOUT verification and completes nothing — a step is done only once PlanComplete proves it with evidence.",
+    off: "Mutate the persisted plan: create a plan, add a step, move a step's ladder status (open → in_progress → claimed), or set the active plan. 'claimed' records progress; the 'proven' transition goes through PlanComplete, which in this harness records the cited evidence without checking it.",
+};
+const PLAN_COMPLETE_DESCRIPTION = {
+    ladder: "The proven transition (machine-checked): mark a plan step proven by citing the toolUseId(s) of the calls that did the work. Each id is resolved against the session event logs (child sessions included); missing or errored results are rejected. Do the work first, then complete the step.",
+    require: "The proven transition (machine-checked): mark a plan step proven by citing the toolUseId(s) of the calls that did the work. Each id is resolved against the session event logs (child sessions included); missing or errored results are rejected. This is the ONLY way a step completes — 'claimed' never counts as done. Do the work first, then complete the step.",
+    off: "Mark a plan step proven by citing the toolUseId(s) of the calls that did the work. Proof checking is off in this harness: the ids are RECORDED as unverified refs, not resolved against an event log, and the step reads 'proven (unverified)'. Cite only calls you actually ran. Do the work first, then complete the step.",
+};
+const GOAL_WRITE_DESCRIPTION = {
+    ladder: "Create a persisted goal ({title, target?, current?, unit?}) in goals.yaml. Goals carry the same open → in_progress → claimed → proven ladder as plan steps.",
+    require: "Create a persisted goal ({title, target?, current?, unit?}) in goals.yaml. Goals carry the same open → in_progress → claimed → proven ladder as plan steps, and reach their target only as proven — create a goal below its target, then prove it with GoalUpdate.",
+    off: "Create a persisted goal ({title, target?, current?, unit?}) in goals.yaml. Goals carry the same open → in_progress → claimed → proven ladder as plan steps.",
+};
+const GOAL_UPDATE_DESCRIPTION = {
+    ladder: "Update a goal: title, target/current progress, or ladder status. 'claimed' is free; 'proven' requires evidence [{toolUseId}] verified against the session event logs, exactly like PlanComplete.",
+    require: "Update a goal: title, target/current progress, or ladder status. 'claimed' is free; 'proven' requires evidence [{toolUseId}] verified against the session event logs, exactly like PlanComplete. A goal reaches its target only as proven: set current to the target in the same call as status 'proven' with evidence.",
+    off: "Update a goal: title, target/current progress, or ladder status. 'claimed' is free; 'proven' requires evidence [{toolUseId}], which this harness records WITHOUT checking it (the goal reads 'proven (unverified)').",
+};
+const GOAL_LIST_DESCRIPTION = {
+    ladder: "List persisted goals with ladder statuses and progress. 'claimed' goals are rendered as unverified.",
+    require: "List persisted goals with ladder statuses and progress. 'claimed' goals are rendered as unverified.",
+    off: "List persisted goals with ladder statuses and progress. 'claimed' and 'proven (unverified)' goals are both unchecked.",
+};
 /** Thrown when a plan-scoped call has neither a planId nor an active plan. */
 export class NoActivePlanError extends Error {
     name = "NoActivePlanError";
@@ -180,6 +367,13 @@ export class NoActivePlanError extends Error {
  * `for (const t of bundle.all) defaultCatalog.register(t)`).
  */
 export function createPlanTools(opts) {
+    const proofMode = opts.proofMode ?? DEFAULT_PROOF_MODE;
+    // A hand-built fragment can carry any string; a typo'd mode must not
+    // quietly become the ladder (the spec schema rejects it at compile time —
+    // this is the same refusal for callers that skip the compiler).
+    if (!PROOF_MODES.includes(proofMode)) {
+        throw new Error(`createPlanTools: proofMode "${String(proofMode)}" is not one of ${PROOF_MODES.join(" | ")}.`);
+    }
     const store = opts.store ??
         createContinuityStore({
             specName: opts.specName,
@@ -188,6 +382,8 @@ export function createPlanTools(opts) {
             ...(opts.sessionRootDir !== undefined ? { sessionRootDir: opts.sessionRootDir } : {}),
             ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
             ...(opts.now !== undefined ? { now: opts.now } : {}),
+            // The store's handoff.md counts `proven` as these tools do (§6.3).
+            proofMode,
         });
     async function emit(event) {
         if (opts.appendEvent !== undefined)
@@ -264,7 +460,7 @@ export function createPlanTools(opts) {
     });
     const planRead = buildTool({
         name: "PlanRead",
-        description: "Read a plan's numbered steps with their proof-ladder statuses. 'claimed' steps are rendered as unverified — only 'proven' steps have machine-checked evidence. Omit planId for the active plan.",
+        description: PLAN_READ_DESCRIPTION[proofMode],
         inputSchema: planReadSchema,
         readOnly: true,
         execute: async (input) => {
@@ -289,7 +485,7 @@ export function createPlanTools(opts) {
     });
     const planUpdate = buildTool({
         name: "PlanUpdate",
-        description: "Mutate the persisted plan: create a plan, add a step, move a step's ladder status (open → in_progress → claimed), or set the active plan. 'claimed' records progress WITHOUT verification — the 'proven' transition goes through PlanComplete with evidence.",
+        description: PLAN_UPDATE_DESCRIPTION[proofMode],
         inputSchema: planUpdateSchema,
         destructive: true, // audit-and-allow (§7.4): a judge call per routine plan update would drown the loop
         execute: async (input, ctx) => {
@@ -318,7 +514,7 @@ export function createPlanTools(opts) {
                 }
                 case "set_step_status": {
                     const planId = await resolvePlanId(input.planId);
-                    await store.setStepStatus(planId, input.step, input.status);
+                    const plan = await store.setStepStatus(planId, input.step, input.status);
                     await emit({
                         kind: "plan_update",
                         payload: {
@@ -330,6 +526,12 @@ export function createPlanTools(opts) {
                         },
                     });
                     markPlanDirty(ctx);
+                    if (proofMode === "require" && input.status === "claimed") {
+                        // `claimed` stays settable under require — it is honest progress
+                        // — but the reply says plainly that it completes nothing.
+                        const note = incompletePlanNote(plan);
+                        return `${planId} step ${input.step} → claimed (unverified — under continuity.proof: require it completes nothing; prove it with PlanComplete({step: ${input.step}, evidence: [{toolUseId}]}))${note !== null ? `\n${note}` : ""}`;
+                    }
                     return `${planId} step ${input.step} → ${input.status}${input.status === "claimed" ? " (unverified — prove it with PlanComplete)" : ""}`;
                 }
                 case "set_active": {
@@ -346,7 +548,7 @@ export function createPlanTools(opts) {
     });
     const planComplete = buildTool({
         name: "PlanComplete",
-        description: "The proven transition (machine-checked): mark a plan step proven by citing the toolUseId(s) of the calls that did the work. Each id is resolved against the session event logs (child sessions included); missing or errored results are rejected. Do the work first, then complete the step.",
+        description: PLAN_COMPLETE_DESCRIPTION[proofMode],
         inputSchema: planCompleteSchema,
         destructive: true,
         execute: async (input, ctx) => {
@@ -360,6 +562,48 @@ export function createPlanTools(opts) {
                         ? { sessionId }
                         : {}),
             }));
+            if (proofMode === "off") {
+                // design/0.8.0 §6.3 — no verification: the step is proven by
+                // assertion, the citations are recorded unresolved, no session is
+                // pinned, and the audit trail says `unverified`, never `verified`.
+                const plan = await store.proveStep(planId, input.step, refs, {
+                    verification: "unverified",
+                });
+                const step = plan.steps.find((s) => s.index === input.step);
+                if (step === undefined || !isProvenByAssertion(step)) {
+                    // The store kept an earlier machine-checked proof rather than
+                    // downgrade it — nothing new was recorded, so nothing is emitted.
+                    return `${planId} step ${input.step} is already proven with verified evidence — nothing recorded.`;
+                }
+                const cited = new Set(refs.map((r) => r.toolUseId));
+                const recorded = (step.unverified ?? []).filter((r) => cited.has(r.toolUseId));
+                for (const ref of recorded) {
+                    await emit({
+                        kind: "action_proof",
+                        payload: {
+                            planId,
+                            step: input.step,
+                            toolUseId: ref.toolUseId,
+                            verdict: "unverified",
+                            ...identityOf(ctx),
+                        },
+                    });
+                }
+                await emit({
+                    kind: "plan_update",
+                    payload: {
+                        planId,
+                        action: "prove_step",
+                        step: input.step,
+                        status: "proven",
+                        ...identityOf(ctx),
+                    },
+                });
+                markPlanDirty(ctx);
+                return `${planId} step ${input.step} proven (unverified) — continuity.proof is off, so the evidence was recorded, not checked: ${recorded
+                    .map(renderUnverifiedRef)
+                    .join(", ")}`;
+            }
             try {
                 const plan = await store.proveStep(planId, input.step, refs);
                 const step = plan.steps.find((s) => s.index === input.step);
@@ -388,9 +632,14 @@ export function createPlanTools(opts) {
                     },
                 });
                 markPlanDirty(ctx);
-                return `${planId} step ${input.step} proven — evidence: ${refs
+                const reply = `${planId} step ${input.step} proven — evidence: ${refs
                     .map((r) => r.toolUseId)
                     .join(", ")}`;
+                // Under require, proving the last open step of a plan whose other
+                // steps are claimed (or proven only by assertion) does not finish
+                // it; say which steps still need a verified proof.
+                const note = proofMode === "require" ? incompletePlanNote(plan) : null;
+                return note !== null ? `${reply}\n${note}` : reply;
             }
             catch (err) {
                 if (err instanceof EvidenceError) {
@@ -412,10 +661,15 @@ export function createPlanTools(opts) {
     });
     const goalWrite = buildTool({
         name: "GoalWrite",
-        description: "Create a persisted goal ({title, target?, current?, unit?}) in goals.yaml. Goals carry the same open → in_progress → claimed → proven ladder as plan steps.",
+        description: GOAL_WRITE_DESCRIPTION[proofMode],
         inputSchema: goalWriteSchema,
         destructive: true,
         execute: async (input, ctx) => {
+            // A new goal's record comes from the input alone, so checking the
+            // input is checking the record (no lock needed, unlike GoalUpdate).
+            const refusal = proofMode === "require" ? goalWriteRefusal(input) : null;
+            if (refusal !== null)
+                throw new ProofRequiredError(refusal);
             const goal = await store.writeGoal({
                 title: input.title,
                 ...(input.target !== undefined ? { target: input.target } : {}),
@@ -432,7 +686,7 @@ export function createPlanTools(opts) {
     });
     const goalUpdate = buildTool({
         name: "GoalUpdate",
-        description: "Update a goal: title, target/current progress, or ladder status. 'claimed' is free; 'proven' requires evidence [{toolUseId}] verified against the session event logs, exactly like PlanComplete.",
+        description: GOAL_UPDATE_DESCRIPTION[proofMode],
         inputSchema: goalUpdateSchema,
         destructive: true,
         execute: async (input, ctx) => {
@@ -445,20 +699,67 @@ export function createPlanTools(opts) {
                         ? { sessionId }
                         : {}),
             }));
-            const goal = await store.updateGoal(input.goalId, {
+            // `require`: the store's one completion path below proven is progress
+            // reaching the target (the Thredz mirror completes the goal on it), so
+            // an update that moves progress is refused when the goal would end up
+            // at its target without a verified proof. Only progress moves are
+            // policed: a title edit on a goal already sitting at its target
+            // completes nothing new.
+            const guarded = proofMode === "require" && (input.current !== undefined || input.target !== undefined);
+            const refuseUnproven = (next) => {
+                const why = goalUpdateRefusal(input.goalId, input, next);
+                if (why !== null)
+                    throw new ProofRequiredError(why);
+            };
+            if (guarded) {
+                // Early refusal on a snapshot, before any evidence is resolved; it
+                // holds whatever store wrapper is in use. The authoritative check is
+                // the store guard below, which sees the record as written under the
+                // lock, so two sessions cannot each pass on a stale read. An unknown
+                // id falls through to the store's own "no goal" error.
+                const existing = (await store.listGoals()).find((g) => g.id === input.goalId);
+                // A call that sets `proven` resolves its evidence (require is the
+                // ladder there), so it lands verified — with a frozen proof,
+                // replacing any assertion — or not at all; the snapshot has nothing
+                // to refuse in it.
+                if (existing !== undefined && input.status !== "proven") {
+                    refuseUnproven({
+                        status: input.status ?? existing.status,
+                        unverified: existing.unverified,
+                        proofs: existing.proofs,
+                        target: input.target ?? existing.target,
+                        current: input.current ?? existing.current,
+                        unit: input.unit ?? existing.unit,
+                    });
+                }
+            }
+            const patch = {
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 ...(input.status !== undefined ? { status: input.status } : {}),
                 ...(input.target !== undefined ? { target: input.target } : {}),
                 ...(input.current !== undefined ? { current: input.current } : {}),
                 ...(input.unit !== undefined ? { unit: input.unit } : {}),
                 ...(evidence !== undefined ? { evidence } : {}),
-            });
+            };
+            // `off` records a proven goal's evidence unresolved (design/0.8.0
+            // §6.3); `require` hands the store its at-target guard; the ladder
+            // makes the exact pre-0.8.0 call.
+            const goal = proofMode === "off"
+                ? await store.updateGoal(input.goalId, patch, { verification: "unverified" })
+                : guarded
+                    ? await store.updateGoal(input.goalId, patch, { guard: (next) => refuseUnproven(next) })
+                    : await store.updateGoal(input.goalId, patch);
+            // `action_proof` is keyed by plan step, so a goal proven by assertion
+            // is marked on its own `goal_update` instead: the log must not show it
+            // the way it shows a verified goal proof.
+            const asserted = input.status === "proven" && isProvenByAssertion(goal);
             await emit({
                 kind: "goal_update",
                 payload: {
                     goalId: goal.id,
                     action: "update",
                     ...(input.status !== undefined ? { status: input.status } : {}),
+                    ...(asserted ? { verification: "unverified" } : {}),
                     ...identityOf(ctx),
                 },
             });
@@ -468,7 +769,7 @@ export function createPlanTools(opts) {
     });
     const goalList = buildTool({
         name: "GoalList",
-        description: "List persisted goals with ladder statuses and progress. 'claimed' goals are rendered as unverified.",
+        description: GOAL_LIST_DESCRIPTION[proofMode],
         inputSchema: goalListSchema,
         readOnly: true,
         execute: async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/tool-plan",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "v0.3.0 Goal 1 — Focus*/Plan*/Goal*/MemoryClear RegisteredTools over @crewhaus/continuity-store: the claimed→proven proof ladder as a tool surface, with plan_update/goal_update/action_proof event emission via an injected append seam.",
   "main": "dist/index.js",
@@ -8,18 +8,19 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/continuity-store": "0.7.0",
-    "@crewhaus/event-log": "0.7.0",
-    "@crewhaus/run-context": "0.7.0",
-    "@crewhaus/tool-builder": "0.7.0",
-    "@crewhaus/tool-catalog": "0.7.0",
+    "@crewhaus/continuity-store": "0.8.0",
+    "@crewhaus/event-log": "0.8.0",
+    "@crewhaus/run-context": "0.8.0",
+    "@crewhaus/tool-builder": "0.8.0",
+    "@crewhaus/tool-catalog": "0.8.0",
     "zod": "^3.23.8"
   },
   "license": "Apache-2.0",
@@ -40,5 +41,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"],
+  "engines": {
+    "bun": ">=1.3.14"
+  }
 }