@cratylus/canon 0.9.0 → 0.11.0

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
@@ -23,18 +24,22 @@
 // every agent in the corpus composed the fragment it claimed to enforce.
 //
 // WHAT IT BLOCKS is what the arrow excludes, and nothing else:
-//   · a dispatch carrying a spec the dispatcher wrote, from a holder whose arrow does
-//     not write spec — the architect skipping the planner, who alone turns a shard into
-//     units;
+//   · a dispatch carrying a spec the dispatcher wrote for a unit of the loop, from a holder
+//     whose arrow does not write spec — the architect skipping the planner, who alone turns
+//     a shard into units;
 //   · a write to the substrate by a holder whose arrow does not write artifact;
-//   · a dispatch whose prompt is the operator's literal words rather than a routed name
-//     — the same dispatch-echo the stance guard catches at turn end, refused here
-//     because at this moment the contract that convicts it is the ROLE's.
-// WHAT IT PASSES: a dispatch to a planner, a dispatch routing a unit name to an
-// implementer, a dispatch to an assayer, a dispatch to the integrator, READING anything,
-// and writing whatever the arrow reserves. Reading is never a block — the architect's
-// contract makes an artifact read a descent, but a read is cheap to undo and a gate
-// that fires on one would wedge every legitimate orientation.
+//   · a dispatch whose prompt is the operator's literal words rather than a routed name or
+//     the holder's own request — the same dispatch-echo the stance guard catches at turn
+//     end, refused here because at this moment the contract that convicts it is the ROLE's.
+// WHAT IT PASSES: a dispatch to a planner, a dispatch routing a unit name to an implementer,
+// a dispatch to an assayer, a dispatch to the integrator, a dispatch outside the loop of
+// realizing the design — a comparison, an audit, a question — in the holder's own words,
+// where the holder's own contract admits it, READING anything, and writing whatever the arrow
+// reserves. The operator saw an ad hoc comparison refused twice because a self-worded prompt
+// was read as a spec; a request is not a spec, the routing discipline binds units of the loop
+// and not everything a holder says to a delegate. Reading is never a block — the architect's
+// contract makes an artifact read a descent, but a read is cheap to undo and a gate that
+// fires on one would wedge every legitimate orientation.
 //
 // FAIL-OPEN, EVIDENCE-CHECKED, RE-ENTRY-CAPPED — all three inherited from the sibling
 // pre-hook, which is also the structural model for the worker. A block whose cited span
@@ -42,7 +47,7 @@
 // error than a missed one.
 export const purviewGuardrail = {
     id: 'purview-guardrail',
-    residue: 'structural-refusal ↾ mid-turn act ∉ role-arrow · deny-before-fire ⟨descent ⟨write(artifact) ∉ writes⟩ · skipped-rung ⟨dispatch(spec the dispatcher wrote) ∄ planner⟩ · dispatch-echo ⟨literal-words ≠ routed-name⟩⟩ · pass ⟨read · act ∈ reserves · dispatch ↦ plan ∨ implement(unit-name) ∨ assay ∨ integrate⟩ · law = the HOLDER-projected role-section ⟨quoted verbatim · ¬ authored-opinion⟩ · shared judge-backend ⟨sibling⟩ · fail-open ∧ evidence-checked ∧ re-entry-capped',
+    residue: 'structural-refusal ↾ mid-turn act ∉ role-arrow · deny-before-fire ⟨descent ⟨write(artifact) ∉ writes⟩ · skipped-rung ⟨dispatch(spec the dispatcher wrote for a unit of the loop) ∄ planner⟩ · dispatch-echo ⟨literal-words ≠ routed-name ∨ own-words⟩⟩ · pass ⟨read · act ∈ reserves · dispatch ↦ plan ∨ implement(unit-name) ∨ assay ∨ integrate ∨ ad-hoc(own-words ∉ loop ↾ contract admits)⟩ · law = the HOLDER-projected role-section ⟨quoted verbatim · ¬ authored-opinion⟩ · shared judge-backend ⟨sibling⟩ · fail-open ∧ evidence-checked ∧ re-entry-capped',
     substrate: 'harness',
     // Bound by holding a role at all: the arrow it judges against is the role's own.
     binds: { dimension: 'role' },
@@ -193,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"
@@ -201,7 +208,7 @@ case "$tool_name" in
 	Agent|SendMessage|Task)
 		body="$(printf '%s' "$input" | jq -r '.tool_input.prompt // .tool_input.message // .tool_input.description // ""' 2>/dev/null || true)"
 		target="$(printf '%s' "$input" | jq -r '.tool_input.subagent_type // .tool_input.agent // .tool_input.name // ""' 2>/dev/null || true)"
-		act="DISPATCH to \\\`\${target:-unnamed}\\\` (codomain: route when it carries a unit name and address only, spec when it carries instructions the dispatcher wrote)"
+		act="DISPATCH to \\\`\${target:-unnamed}\\\` (codomain: route when it carries a unit name and address only, spec when it carries instructions the dispatcher wrote for a unit of the loop, request when it carries the dispatcher's own words outside the loop)"
 		;;
 	Write|Edit|MultiEdit|NotebookEdit)
 		body="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.path // .tool_input.notebook_path // ""' 2>/dev/null || true)"
@@ -216,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)"
@@ -275,9 +290,11 @@ feedback="PURVIEW GUARDRAIL — denied this $tool_name call: it falls outside th
 role contract declares. $reason  Delegation is a THEOREM of that arrow, not an option: an act whose \\
 domain or codomain lies outside it goes to the role that owns it — a decomposition of a shard to a \\
 planner, a build to an implementer, an artifact reading to an assayer, a merge or a whole check to \\
-the integrator. Hand it over by name and carry on with what the contract reserves. (Legitimate and \\
-NOT blocked here: reading anything, dispatching to a planner, routing a unit name to an implementer, \\
-an assayer or the integrator, and performing any act the contract's own \\\`reserves\\\` clause names.)"
+the integrator. Hand a unit of the loop over by name and carry on with what the contract reserves. \\
+(Legitimate and NOT blocked here: reading anything, dispatching to a planner, routing a unit name to \\
+an implementer, an assayer or the integrator, dispatching a request outside the loop to whichever role \\
+or agent fits it in your own rectified words where your contract admits it, and performing any act the \\
+contract's own \\\`reserves\\\` clause names.)"
 
 jq -cn --arg r "$feedback" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'
 exit 0
@@ -324,8 +341,10 @@ durative concept lattice — the design.
 An act has a **domain** (the layer it consumes) and a **codomain** (the layer it produces):
 
 - a DISPATCH that carries a unit name and its address only produces a **route**; a DISPATCH that
-  carries instructions the dispatcher wrote produces a **spec** — those instructions are the layer
-  being written;
+  carries instructions the dispatcher wrote for a unit of the loop the contract names produces a
+  **spec** — those instructions are the layer being written; a DISPATCH that carries a request in
+  the dispatcher's own words, outside that loop, produces neither: it is a **request**, and it is
+  in the arrow exactly when the contract says so;
 - a WRITE to a source or config file produces an **artifact**;
 - reading anything at all produces **nothing**, and is never a breach.
 
@@ -338,12 +357,14 @@ whole test, and it is mechanical.
   The contract usually names this: \`descent\`. The path in the payload is the evidence.
 - **A dispatch whose codomain is \`spec\` by a holder whose \`writes\` set excludes \`spec\`.** This is
   the skipped rung: a holder that writes only the design and its routes has handed a delegate
-  instructions it wrote itself, where only a planner turns a shard into units. The prompt is the
-  evidence.
-- **A dispatch whose prompt is the operator's literal words rather than a routed name.** The
-  contract that convicts this is the same clause: transcription is not authorship, and a dispatch
-  carries a name, not instructions. Evidence is the prompt reading as relayed instructions rather
-  than a unit name with its address.
+  instructions it wrote itself for a unit of the loop — the prompt names a unit or a plan, or tells
+  the delegate what to build, change or verify in a unit's files — where only a planner turns a shard
+  into units. The prompt is the evidence.
+- **A dispatch whose prompt is the operator's literal words** rather than a routed name or the
+  holder's own request. The contract that convicts this is the same clause: transcription is not
+  authorship. Evidence is the prompt reading as the operator's text relayed — addressed to the
+  holder, or in the operator's own voice — rather than as a request the holder rectified and worded
+  itself.
 
 ## What to PASS — and these are the majority
 
@@ -354,6 +375,11 @@ whole test, and it is mechanical.
   integrator for gate, merge and record). A dispatch to a planner, a dispatch routing a unit name
   to an implementer, a dispatch to an assayer and a dispatch to the integrator are the arrow
   WORKING, whether the contract's \`writes\` names \`route\` or not.
+- **A dispatch the contract admits in the holder's own words.** Where the contract states that a
+  request outside the loop — a comparison, an audit, a question — may go to any role or agent that
+  fits it, a dispatch carrying such a request in the holder's own words is the contract working,
+  whichever role it names. It writes no spec: it names no unit of the loop and hands no
+  instructions for building one. Do not read a request's being self-worded as a spec.
 - **Any act the \`reserves\` clause names**, whatever it is.
 - **A write by a holder whose \`writes\` set includes \`artifact\`.** Most agents in most corpora
   build. Do not read a contract's other clauses as narrowing an arrow that plainly permits the act.

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,sFAAsF;AACtF,wFAAwF;AACxF,aAAa;AACb,gFAAgF;AAChF,wFAAwF;AACxF,kFAAkF;AAClF,0EAA0E;AAC1E,gFAAgF;AAChF,yFAAyF;AACzF,sFAAsF;AACtF,oFAAoF;AACpF,8DAA8D;AAC9D,EAAE;AACF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,odAAod;IACtd,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOd;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Ed;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;