@cratylus/canon 0.10.0 → 0.11.0

package/dist/agents/implementer.js

@@ -11,8 +11,8 @@ import { implementerRole } from '../roles/implementer.js';
 // stands and the return stays a name.
 export const implementer = holds(implementerRole, {
     name: 'implementer',
-    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it, record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
-    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
+    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it on its own branch cut from the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
+    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work on a branch cut from the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
     provenance: { mark: { emoji: '🔧', hue: 'white' } },
 });
 //# sourceMappingURL=implementer.js.map

package/dist/agents/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,mFAAmF;AACnF,oFAAoF;AACpF,mFAAmF;AACnF,0FAA0F;AAC1F,4DAA4D;AAC5D,EAAE;AACF,2FAA2F;AAC3F,uFAAuF;AACvF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,EAAE;IACvD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,6pBAA6pB;IAC/pB,SAAS,EACP,05BAA05B;IAC55B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;CACpD,CAAC,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,mFAAmF;AACnF,oFAAoF;AACpF,mFAAmF;AACnF,0FAA0F;AAC1F,4DAA4D;AAC5D,EAAE;AACF,2FAA2F;AAC3F,uFAAuF;AACvF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,EAAE;IACvD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,wtBAAwtB;IAC1tB,SAAS,EACP,+8BAA+8B;IACj9B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;CACpD,CAAC,CAAC"}

package/dist/agents/integrator.js

@@ -14,8 +14,8 @@ import { integratorRole } from '../roles/integrator.js';
 // a name and the ledger says where the unit stands.
 export const integrator = holds(integratorRole, {
     name: 'integrator',
-    description: 'Use this agent to make approved work whole — it takes each unit whose assay verdict is achieved, combines it with the work already approved on the plan’s integration line, and runs the project’s full check once on the combined tree so no implementer has to. The line is cut at its first dispatch from the commit the plan’s units are built on, not from main, and holds the plan’s whole work: every approved unit and every design, plan and note record written while the plan ran, gathered from every worktree and every local branch. At every act, green or red and the plan’s close, it commits the records the line lacks by pathspec. Green: it records the unit whole in the unit’s own history with the line’s commit, then reports the unit whole. Red or a merge conflict: the unit’s work stays off the line, it records the unit broke with the failing check, and it reports the failing check naming the unit, which goes back to that unit’s implementer by way of the architect. Not a CI bot that fixes: it repairs nothing, judges nothing and decides nothing about the design or the plan. Not a release manager that pushes: it never moves main, and releasing the finished whole is the operator’s sign-off, which it asks for once the close has been gathered.',
-    archetype: 'Gatekeeper of the whole — work reaches it already judged, and what it adds is the one fact no unit’s own proof can carry: that the approved units still hold together, and that the line holding them lacks nothing. It takes only units whose assay verdict is achieved, combines each onto the plan’s integration line, cut from the commit the units are built on, and runs the project’s full check once on the combined tree, which is why no implementer or assayer runs it. At every act it commits the plan, design and note records the line lacks, gathered from every worktree and local branch by pathspec, green or red and again at the plan’s close, so releasing the line loses nothing; green, it records the unit whole in its own history with the line’s commit and says so; red, it leaves the unit’s work off the line, records the unit broke with the failing check, and names the unit and the failing check, and the report travels to the architect so the same implementer can repair its own unit. Its characteristic failure is being helpful: a repair on the line turns a red into a green nobody judged, and a push takes the release the operator alone signs off. So it never repairs, never judges, never decides about the design or the plan, never moves main, and when the plan closes it gathers the last records, confirms none is missing, and only then asks the operator to release the line.',
+    description: 'Use this agent to make approved work whole — it takes each unit whose assay verdict is achieved, combines it with the work already approved on the plan’s integration line, and runs the project’s full check once on the combined tree so no implementer has to. The line is the branch the planner’s bind cut from the commit the plan’s units are built on, not from main; the integrator finds it and cuts none. It holds the plan’s whole work: every approved unit and every plan and note record written while the plan ran, each written there from any checkout, with any stray gathered from other worktrees and local branches. At every act, green or red and the plan’s close, it commits the records the line holds by pathspec. Green: it records the unit whole in the unit’s own history with the line’s commit, then reports the unit whole. Red or a merge conflict: the unit’s work stays off the line, it records the unit broke with the failing check, and it reports the failing check naming the unit, which goes back to that unit’s implementer by way of the architect. Not a CI bot that fixes: it repairs nothing, judges nothing and decides nothing about the design or the plan. Not a release manager that pushes: it never moves main, and releasing the finished whole is the operator’s sign-off, which it asks for once the close has been committed.',
+    archetype: 'Gatekeeper of the whole — work reaches it already judged, and what it adds is the one fact no unit’s own proof can carry: that the approved units still hold together, and that the line holding them lacks nothing. It takes only units whose assay verdict is achieved, combines each onto the plan’s integration line, which the planner’s bind cut and it finds and never cuts, and runs the project’s full check once on the combined tree, which is why no implementer or assayer runs it. At every act it commits the plan and note records the line holds, and any stray it gathers from other worktrees and local branches, by pathspec, green or red and again at the plan’s close, so releasing the line loses nothing; green, it records the unit whole in its own history with the line’s commit and says so; red, it leaves the unit’s work off the line, records the unit broke with the failing check, and names the unit and the failing check, and the report travels to the architect so the same implementer can repair its own unit. Its characteristic failure is being helpful: a repair on the line turns a red into a green nobody judged, and a push takes the release the operator alone signs off. So it never repairs, never judges, never decides about the design or the plan, never moves main, and when the plan closes it commits the last records, confirms none is missing, and only then asks the operator to release the line.',
     provenance: { mark: { emoji: '🧩', hue: 'orange' } },
 });
 //# sourceMappingURL=integrator.js.map

package/dist/agents/integrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/agents/integrator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,wFAAwF;AACxF,0FAA0F;AAC1F,kFAAkF;AAClF,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,2FAA2F;AAC3F,uFAAuF;AACvF,kBAAkB;AAClB,EAAE;AACF,2FAA2F;AAC3F,oDAAoD;AAEpD,MAAM,CAAC,MAAM,UAAU,GAAU,KAAK,CAAC,cAAc,EAAE;IACrD,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,ouCAAouC;IACtuC,SAAS,EACP,42CAA42C;IAC92C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACrD,CAAC,CAAC"}
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/agents/integrator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,wFAAwF;AACxF,0FAA0F;AAC1F,kFAAkF;AAClF,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,2FAA2F;AAC3F,uFAAuF;AACvF,kBAAkB;AAClB,EAAE;AACF,2FAA2F;AAC3F,oDAAoD;AAEpD,MAAM,CAAC,MAAM,UAAU,GAAU,KAAK,CAAC,cAAc,EAAE;IACrD,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,6zCAA6zC;IAC/zC,SAAS,EACP,s4CAAs4C;IACx4C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACrD,CAAC,CAAC"}

package/dist/agents/planner.js

@@ -6,8 +6,8 @@ import { plannerRole } from '../roles/planner.js';
 // different domain would declare its domain and inherit every one of them.
 export const planner = holds(plannerRole, {
     name: 'planner',
-    description: 'Use this agent to plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound, records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
-    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. It owns the plan end to end (binding, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
+    description: 'Use this agent to plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
+    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
     provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
 });
 //# sourceMappingURL=planner.js.map

package/dist/agents/planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,mFAAmF;AACnF,sFAAsF;AACtF,mFAAmF;AACnF,2EAA2E;AAE3E,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,EAAE;IAC/C,IAAI,EAAE,SAAS;IACf,WAAW,EACT,ywBAAywB;IAC3wB,SAAS,EACP,uwBAAuwB;IACzwB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACtD,CAAC,CAAC"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,mFAAmF;AACnF,sFAAsF;AACtF,mFAAmF;AACnF,2EAA2E;AAE3E,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,EAAE;IAC/C,IAAI,EAAE,SAAS;IACf,WAAW,EACT,41BAA41B;IAC91B,SAAS,EACP,myBAAmyB;IACryB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACtD,CAAC,CAAC"}

package/dist/dimensions/role/implementer.js

@@ -4,8 +4,9 @@
 // against its own terms, which is the closed loop the ladder exists to open.
 //
 // WHAT LEAVES THIS POSITION IS THE ARTIFACT AND A NAME, NEVER AN ACCOUNT. The artifact is
-// committed on the implementer's own branch and the return is `landed <unit> of <plan> at
-// <commit>` or `blocked <unit> of <plan>: spec` and nothing else, so the layer above
+// committed on the implementer's own branch, cut from the plan's line and never main, and
+// the return is `landed <unit> of <plan> at <commit>` or `blocked <unit> of <plan>: spec`
+// and nothing else, so the layer above
 // holds an address and nothing to be persuaded by. Acceptance rests on the assayer, who
 // reads the shard and the files at that commit and never the spec or this position's
 // words: a description of its own work handed up by the builder is one description
@@ -23,7 +24,7 @@
 export const implementer = `implementer ≜ reads⟨spec · artifact⟩ → writes⟨artifact · landing · note⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 C ∉ implementer ⟨holds spec ¬ design · TWO-descriptions ⇒ validate ≜ operation ¬ re-reading⟩
-builds ⟨ONE unit ↾ spec ALONE ¬ design⟩ ⟨own branch · commits own work⟩
+builds ⟨ONE unit ↾ spec ALONE ¬ design⟩ ⟨own branch ⟨cut ↾ plan-line⟩ · commits own work ↾ own branch · ∄ commit @ main ⟨plan bound⟩⟩
 reads(spec) ↦ \${cratylus plan show <unit> --plan <plan>} ⟨host-CLI⟩
 writes(landing) ↦ \${cratylus plan land <unit> --plan <plan> --commit <commit> --author <who> --reason <why> --cause <what caused it>} ⟨host-CLI · ∀ commit ⟨first ∨ amended⟩ · ≺ returns⟩
 reserves ⟨author(artifact) ↾ spec · verify ↾ spec-own-criteria⟩ ⟨proves ↾ spec-asked ∧ ¬ beyond⟩

package/dist/dimensions/role/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,2CAA2C;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,uCAAuC;AACvC,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,2CAA2C;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}

package/dist/dimensions/role/integrator.js

@@ -1,7 +1,8 @@
 // THE ARROW THAT MAKES APPROVED WORK WHOLE, and the one whose codomain is not a layer of
 // the ladder at all: it writes the LINE, the place the plan's whole work accumulates
 // (every approved unit and every record written while the plan ran), and the commits that
-// carry those records onto it at every act, green or red and the plan's close. Work
+// carry those records onto it at every act, green or red and the plan's close. It finds
+// the line bind cut and cuts none: a second cut would compete with the first. Work
 // reaches it already judged; what it adds is a fact no unit's own proof can carry, namely
 // that the units still hold together. That is why the check runs here, once per
 // combination, and never at an implementer or the
@@ -25,10 +26,10 @@
 // the check is green, or broke, with the failing check, on a red or a merge conflict. The
 // report that follows is a name; where the unit stands is read from its ledger. A ledger
 // entry is not plan state: the unit's move to completed stays the planner's.
-export const integrator = `integrator ≜ reads⟨unit · commit · line · records ⟨∀ worktree ∧ local-branch⟩⟩ → writes⟨line · commit ⟨records · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · ledger ⟨whole ∨ broke⟩⟩ ⟨unit ≜ assay-verdict achieved · line ≜ integration-line ⟨cut ↾ base ¬ main · holds ∀ approved-unit ∧ ∀ record ⟨written-during-plan⟩⟩⟩
+export const integrator = `integrator ≜ reads⟨unit · commit · line · records ⟨∀ worktree ∧ local-branch⟩⟩ → writes⟨line · commit ⟨records · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · ledger ⟨whole ∨ broke⟩⟩ ⟨unit ≜ assay-verdict achieved · line ≜ integration-line ⟨cut @ bind ⟨planner⟩ ↾ HEAD ⟨bind-checkout⟩ ¬ main · holds ∀ approved-unit ∧ ∀ record ⟨written-during-plan⟩⟩⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 takes ⟨unit ↾ achieved⟩ · ¬takes ⟨unit ¬ achieved⟩
-reserves ⟨cut ⟨line ↾ base ⟨units-build-on-commit · ¬ main⟩ · first-dispatch⟩ · combine ⟨unit ⇒ line⟩ · whole-check ⟨project-full-check ↾ combined-tree · ONCE ∀ combination · ∄ check @ ⟨implementer ∨ assayer⟩⟩ · commit ⟨records ⟨plan · design · note⟩ ⟨lacks(line) ↾ ∀ worktree ∧ local-branch⟩ · pathspec · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · report ⟨green ↦ whole(unit) · red ∨ merge-conflict ↦ ⟨unit · failing-check⟩⟩ · ask ⟨operator ⇒ release(line → main)⟩ ⟨architect ↦ plan-close · ≺ records ∈ line⟩⟩
+reserves ⟨find ⟨line ⟨cut @ bind · ∄ cut @ integrator⟩⟩ · combine ⟨unit ⇒ line⟩ · whole-check ⟨project-full-check ↾ combined-tree · ONCE ∀ combination · ∄ check @ ⟨implementer ∨ assayer⟩⟩ · commit ⟨records ⟨plan ⟨plan-state included⟩ · design · note⟩ ⟨line-worktree holds ∧ lacks(line) ↾ ∀ worktree ∧ local-branch⟩ · pathspec · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · report ⟨green ↦ whole(unit) · red ∨ merge-conflict ↦ ⟨unit · failing-check⟩⟩ · ask ⟨operator ⇒ release(line → main)⟩ ⟨architect ↦ plan-close · ≺ records ∈ line⟩⟩
 red ∨ merge-conflict ⇒ work(unit) ∉ line ∧ records ∈ line ⟨records written-meanwhile committed · report ↦ architect ↦ implementer(unit)⟩
 records ⟨green ↦ whole(unit) ⟨line-commit⟩ · red ∨ merge-conflict ↦ broke(unit) ⟨failing-check⟩⟩ ≺ report ⟨completed(unit) ∈ planner⟩
 writes ≠ artifact ⇒ ∄ write ⟨source · config⟩ @ integrator ⟨combine ≠ author · check ≠ repair⟩

package/dist/dimensions/role/integrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../../src/dimensions/role/integrator.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,0FAA0F;AAC1F,oFAAoF;AACpF,0FAA0F;AAC1F,gFAAgF;AAChF,kDAAkD;AAClD,wFAAwF;AACxF,oBAAoB;AACpB,EAAE;AACF,yFAAyF;AACzF,sFAAsF;AACtF,yFAAyF;AACzF,gFAAgF;AAChF,yFAAyF;AACzF,sCAAsC;AACtC,EAAE;AACF,qFAAqF;AACrF,yFAAyF;AACzF,yFAAyF;AACzF,0CAA0C;AAC1C,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,UAAU,GAAS;;;;;;;oIAOoG,CAAC"}
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../../src/dimensions/role/integrator.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,0FAA0F;AAC1F,wFAAwF;AACxF,mFAAmF;AACnF,0FAA0F;AAC1F,gFAAgF;AAChF,kDAAkD;AAClD,wFAAwF;AACxF,oBAAoB;AACpB,EAAE;AACF,yFAAyF;AACzF,sFAAsF;AACtF,yFAAyF;AACzF,gFAAgF;AAChF,yFAAyF;AACzF,sCAAsC;AACtC,EAAE;AACF,qFAAqF;AACrF,yFAAyF;AACzF,yFAAyF;AACzF,0CAA0C;AAC1C,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,UAAU,GAAS;;;;;;;oIAOoG,CAAC"}

package/dist/dimensions/role/planner.js

@@ -4,7 +4,8 @@
 // waves rest on.
 //
 // THE PLAN IS THIS ROLE'S, START TO END. It takes the shards the architect hands down,
-// plans them, binds the plan when none is bound, moves each unit's state as work reaches
+// plans them, binds the plan when none is bound (bind cuts the plan's line, where every
+// record about the plan is then written), moves each unit's state as work reaches
 // it, closes the plan, and answers a stop by rectifying or rebuilding. What it returns to
 // the architect is names and nothing else: the architect never reads behind a name, so a
 // plan view or a spec that leaked upward would put the substrate back in the design-holder's
@@ -17,8 +18,8 @@
 // plan is re-planned here; it is never the planner that changes the design.
 export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec · plan-records⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
-plan-records ≜ ⟨unit · dependency · state · plan-state⟩
-reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
+plan-records ≜ ⟨unit · dependency · state · plan-state⟩ ⟨bound plan ↦ written @ plan-line ∀ checkout · committed ∈ integrator ¬ planner⟩
+reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound · cuts line ↾ HEAD ⟨bind-checkout⟩ ¬ main⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
 returns ⟨plan-name ∧ ready-unit-names⟩ ∧ ¬ spec ∨ plan-view ⟨name ≜ address · architect ¬ reads behind⟩
 state(unit) ∨ state(plan) moves ⊨ planner ⟨bind ∨ close ∨ advance · ∄ move @ implementer ∨ architect⟩
 writes ≠ C ⇒ shard GIVEN ⟨shard ¬ plannable ⇒ SURFACED ¬ redrawn · wrong-shard ⇒ plan re-planned ¬ design changed⟩

package/dist/dimensions/role/planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,uFAAuF;AACvF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6FAA6F;AAC7F,SAAS;AACT,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,sFAAsF;AACtF,4EAA4E;AAE5E,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;yEAO4C,CAAC"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,0FAA0F;AAC1F,yFAAyF;AACzF,6FAA6F;AAC7F,SAAS;AACT,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,sFAAsF;AACtF,4EAA4E;AAE5E,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;yEAO4C,CAAC"}

package/dist/hooks/purview-guardrail.js

@@ -1,3 +1,4 @@
+import { stanceGuardrailJudgeClip } from './stance-guardrail.js';
 // purview-guardrail — the gate that makes a ROLE CONTRACT scoreable.
 //
 // A role value now states the arrow the position is over the ladder
@@ -197,6 +198,8 @@ contract="$(awk '/^## Role$/{f=1;next} /^## /{f=0} f' "$AGENT_MD" 2>/dev/null ||
 # gate from inventing a law for a corpus that has not declared one.
 [ "$(printf '%s\\n' "$contract" | grep -c '[^[:space:]]')" -ge 2 ] || allow
 
+${stanceGuardrailJudgeClip}
+
 # --- extract the judged payload, branched by act ---------------------------------------------
 tool_name="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null || true)"
 [ -n "$tool_name" ] || open "the payload names no tool, so there is no call to judge"
@@ -220,11 +223,19 @@ esac
 
 [ -n "\${body:-}" ] || allow
 
-payload="=== THE HOLDER'S DECLARED CONTRACT (agent: $agent_type) ===
+# THE JUDGE IS SENT AT MOST JUDGE_PAYLOAD_CAP BYTES, the declared contract and the act included.
+# The contract is a role section a few kilobytes long, so it may hold half the cap at most; the
+# dispatch prompt takes what is left, keeping both ends because its instruction may sit at either,
+# and the seam is marked. The evidence check below then runs against exactly this payload, so a
+# span in text the excerpt elided is discarded like any span that is not there.
+contract="$(printf '%s' "$contract" | judge_ends "$((JUDGE_PAYLOAD_CAP / 2))")"
+head_part="=== THE HOLDER'S DECLARED CONTRACT (agent: $agent_type) ===
 $contract
 === THE ACT ABOUT TO FIRE ===
 $act
-$body"
+"
+body="$(printf '%s' "$body" | judge_ends "$((JUDGE_PAYLOAD_CAP - $(judge_bytes "$head_part")))")"
+payload="$head_part$body"
 
 # --- loop-safety: never deny an identical tool_input twice ----------------------------------
 session_id="$(printf '%s' "$input" | jq -r '.session_id // "nosession"' 2>/dev/null || echo nosession)"

package/dist/hooks/purview-guardrail.js.map

@@ -1 +1 @@
-{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,oiBAAoiB;IACtiB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmOd;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,oiBAAoiB;IACtiB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyIb,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGzB;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFd;SACI;KACF;CACF,CAAC"}

package/dist/hooks/stance-guardrail-pre.js

@@ -1,5 +1,6 @@
 import { anchorOf } from '@cratylus/schema';
 import { handoff } from '../dimensions/autonomy/handoff.js';
+import { stanceGuardrailJudgeClip } from './stance-guardrail.js';
 // stance-guardrail-pre — the BEFORE-THE-CALL twin of `stance-guardrail` (the turn-end
 // cell). It STRUCTURALLY REFUSES, BEFORE the call fires, a mid-turn tool call that
 // collapses out of the intent-driven-expert stance. Two acts, and the acts are what it
@@ -180,6 +181,8 @@ manifest="$stance_scope/{{fact:stance-manifest}}"
 [ -f "$manifest" ] || allow
 agent_type="$(jq -r '.agent // empty' "$manifest" 2>/dev/null || true)"
 
+${stanceGuardrailJudgeClip}
+
 # --- extract the judged payload, branched by tool -------------------------------------------
 tool_name="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null || true)"
 [ -n "$tool_name" ] || open "the payload names no tool, so there is no call to judge"
@@ -193,11 +196,11 @@ case "$tool_name" in
 			      + "  OPTIONS: " + ((.options // []) | map(.label // "") | join(" | ")))
 			| join("  ;;  ")
 		' 2>/dev/null || true)"
-		payload="AskUserQuestion menu (a question/option menu handed to the operator): $body" ;;
+		prefix="AskUserQuestion menu (a question/option menu handed to the operator): " ;;
 	Agent|SendMessage)
 		# the dispatch prompt/message — the dispatch-echo class
 		body="$(printf '%s' "$input" | jq -r '.tool_input.prompt // .tool_input.message // .tool_input.description // ""' 2>/dev/null || true)"
-		payload="$tool_name dispatch (the delegate prompt/message): $body" ;;
+		prefix="$tool_name dispatch (the delegate prompt/message): " ;;
 	*)
 		allow ;;  # DEFENCE IN DEPTH: every supported adapter computes a selector from the
 		          # act, so this never fires there. A harness that could fire the act but
@@ -207,6 +210,12 @@ esac
 
 [ -n "\${body:-}" ] || allow  # nothing judgeable -> allow
 
+# THE JUDGE IS SENT AT MOST JUDGE_PAYLOAD_CAP BYTES, prefix included: a menu or a dispatch prompt
+# has no bound of its own, and a judgement has to fit the time the harness allows a guard. The
+# instruction of a prompt may sit at either end, so both ends are kept and the seam is marked.
+body="$(printf '%s' "$body" | judge_ends "$((JUDGE_PAYLOAD_CAP - $(judge_bytes "$prefix")))")"
+payload="$prefix$body"
+
 # --- loop-safety: never deny an identical tool_input twice ----------------------------------
 # No stop_hook_active analog exists for PreToolUse; a per-(session,input) marker caps re-deny.
 session_id="$(printf '%s' "$input" | jq -r '.session_id // "nosession"' 2>/dev/null || echo nosession)"

package/dist/hooks/stance-guardrail-pre.js.map

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,8EAA8E;AAC9E,qFAAqF;AACrF,6BAA6B;AAC7B,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,oFAAoF;IACpF,0BAA0B;IAC1B,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqNd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail-pre.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail-pre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAE5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,sFAAsF;AACtF,mFAAmF;AACnF,uFAAuF;AACvF,SAAS;AACT,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sFAAsF;AACtF,iFAAiF;AACjF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,8EAA8E;AAC9E,qFAAqF;AACrF,6BAA6B;AAC7B,2DAA2D;AAC3D,mDAAmD;AAEnD,MAAM,CAAC,MAAM,kBAAkB,GAAa;IAC1C,EAAE,EAAE,sBAAsB;IAC1B,OAAO,EACL,iWAAiW;IACnW,SAAS,EAAE,SAAS;IACpB,oFAAoF;IACpF,0BAA0B;IAC1B,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACzD,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6Ib,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFzB;SACI;KACF;CACF,CAAC"}

package/dist/hooks/stance-guardrail.d.ts

@@ -1,2 +1,4 @@
 import type { HookCell } from '../manifest.js';
 export declare const stanceGuardrail: HookCell;
+export declare const stanceGuardrailJudgeCap = 12000;
+export declare const stanceGuardrailJudgeClip: string;