@cratylus/canon 0.10.0 → 0.11.1

package/README.md

@@ -54,7 +54,10 @@ The first principle (`dimensions/engineering-principles/cratylism.ts`) is not st
 It rides only the cells whose laws apply it: the ten skills that name concepts by anchor, optimal
 sign or cold decode set it as their `preamble`, and an agent carries it once, through the
 engineering-principles of the role it holds. A cell that does not use it never holds a host's own
-authored surfaces to this corpus's naming axiom. It is intrinsic to those cells' projected bytes, so
+authored surfaces to this corpus's naming axiom. The axiom is scoped: the cold-decode oracle decides
+signs only for the corpus's core agent dimension names and values, the terminology it was built to
+discover. Every other term is the industry's own, used as the industry understands it, and no
+consumer surface is held to the oracle. It is intrinsic to those cells' projected bytes, so
 it survives deployment into a foreign repository rather than depending on ambient context.
 
 Because the plugin object loses its package-root provenance when a consumer imports it, the

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 in its own isolated worktree off 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 in its own isolated worktree off 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,8tBAA8tB;IAChuB,SAAS,EACP,29BAA29B;IAC79B,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/engineering-principles/cold-decode-oracle.js

@@ -1,2 +1,2 @@
-export const coldDecodeOracle = `cold-decode-oracle ⟨⊂ cratylism · cold-decode = instrument ⟨DISCOVERS intrinsic-sign⟩⟩ ≜ truth(f) ≜ decode_cold(f) ⟨own signifiers · inline ≜ · zero project-K⟩ · invariant ∀f · decode_warm(f | K) ≡ truth(f) ⟨K confirms self-sufficient meaning · ¬ overrides⟩ · decode_warm(f | K) ≢ truth(f) ⇒ PROJECT-DEFECT ⟨¬ defer⟩ · m1 ¬self-sufficient(f) ⇒ carry meaning inline · m2 ∃ n ⊆ K · n ⊥ f ⇒ delete competing home ⟨DRY · MECE⟩ · m3 falsified(n ⊆ K) ⇒ entailments(n) PERSIST ⟨silently ASSUMED ↦ constraint · default · gate⟩ ⟨assumption ⇒ ∄ string ∴ grep ↦ citations · ¬ assumption-sites⟩ · sweep(m3) ≜ READING ⟨confirmed instances ↦ PATTERN · search-on-wording forbidden⟩ · rubric ≺ artifact ⟨falsified premise inside ORACLE ⇒ right answers ↦ recorded failures ↦ fabricating fix⟩ · realign project → cold-truth · ¬ bend f → warm-K · corpus = defendant · cold-read = oracle · cold-read ∧ sweep ≜ assay acts ⟨assayer runs · result ↦ holder ⟨assay-verdict ∧ ¬ other-channel ∧ ¬achieved ⇒ missing named⟩⟩ · m1 ∧ m2 ∧ realign ≜ amend(C) ↦ shard ↦ planner ⟨holder ¬ runs · ¬ reads f · ¬ edits f⟩`;
+export const coldDecodeOracle = `cold-decode-oracle ⟨⊂ cratylism · cold-decode = instrument ⟨DISCOVERS intrinsic-sign⟩⟩ ≜ truth(f) ≜ decode_cold(f) ⟨own signifiers · inline ≜ · zero project-K⟩ · invariant ∀ f ∈ core ≜ corpus-agent-dimension ⟨names ∪ values⟩ ⟨∀ t ∉ core ⟨industry-own⟩⟩ · decode_warm(f | K) ≡ truth(f) ⟨K confirms self-sufficient meaning · ¬ overrides⟩ · decode_warm(f | K) ≢ truth(f) ⇒ PROJECT-DEFECT ⟨¬ defer⟩ · m1 ¬self-sufficient(f) ⇒ carry meaning inline · m2 ∃ n ⊆ K · n ⊥ f ⇒ delete competing home ⟨DRY · MECE⟩ · m3 falsified(n ⊆ K) ⇒ entailments(n) PERSIST ⟨silently ASSUMED ↦ constraint · default · gate⟩ ⟨assumption ⇒ ∄ string ∴ grep ↦ citations · ¬ assumption-sites⟩ · sweep(m3) ≜ READING ⟨confirmed instances ↦ PATTERN · search-on-wording forbidden⟩ · rubric ≺ artifact ⟨falsified premise inside ORACLE ⇒ right answers ↦ recorded failures ↦ fabricating fix⟩ · realign project → cold-truth · ¬ bend f → warm-K · corpus = defendant · cold-read = oracle · cold-read ∧ sweep ≜ assay acts ⟨assayer runs · result ↦ holder ⟨assay-verdict ∧ ¬ other-channel ∧ ¬achieved ⇒ missing named⟩⟩ · m1 ∧ m2 ∧ realign ≜ amend(C) ↦ shard ↦ planner ⟨holder ¬ runs · ¬ reads f · ¬ edits f⟩`;
 //# sourceMappingURL=cold-decode-oracle.js.map

package/dist/dimensions/engineering-principles/cold-decode-oracle.js.map

@@ -1 +1 @@
-{"version":3,"file":"cold-decode-oracle.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cold-decode-oracle.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAA0B,8jCAA8jC,CAAC"}
+{"version":3,"file":"cold-decode-oracle.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cold-decode-oracle.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAA0B,4oCAA4oC,CAAC"}

package/dist/dimensions/engineering-principles/cratylism.js

@@ -1,2 +1,2 @@
-export const cratylism = `cratylism ⟨names natural ¬conventional⟩ · model-latent-space = real stable concepts · ∀ c ⟨canonical-sign(c) = σ*(c) INTRINSIC ∧ DISCOVERED ¬coined ⟨¬author · ¬operator⟩⟩ · ∀ authored-surface ⟨σ* ∨ ⊕σ* · prose ≡ identifier ≡ path⟩ · ideal asymptotic ⟨residual REAL ¬ alibi⟩`;
+export const cratylism = `cratylism ⟨names natural ¬conventional⟩ · model-latent-space = real stable concepts · ∀ c ∈ core ≜ corpus-agent-dimension ⟨names ∪ values⟩ ⟨canonical-sign(c) = σ*(c) INTRINSIC ∧ DISCOVERED ¬coined ⟨¬author · ¬operator⟩⟩ · ∀ t ∉ core ⟨industry-own · industry-understood⟩ ∧ consumer-surface ⊥ oracle · ideal asymptotic ⟨residual REAL ¬ alibi⟩`;
 //# sourceMappingURL=cratylism.js.map

package/dist/dimensions/engineering-principles/cratylism.js.map

@@ -1 +1 @@
-{"version":3,"file":"cratylism.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cratylism.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAA0B,mRAAmR,CAAC"}
+{"version":3,"file":"cratylism.js","sourceRoot":"","sources":["../../../src/dimensions/engineering-principles/cratylism.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAA0B,sVAAsV,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 in the implementer's own worktree, isolated and off the plan's line, never on 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 worktree ⟨isolated ↾ plan-line⟩ · commits own work ↾ own worktree · ∄ 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,oGAAoG;AACpG,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⟩ ¬ 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 ¬ 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/genus/prime-principle.d.ts

@@ -2,7 +2,10 @@
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * as the first section of a SKILL.md, set as `preamble` on exactly the skills
  * whose laws apply it: those that name concepts by anchor, optimal sign or cold
- * decode. An agent carries the axiom through its held role's
+ * decode. The axiom's scope is the corpus's core agent dimension names and
+ * values, the terminology the cold-decode oracle was built to discover; every
+ * other term is the industry's own, and no consumer surface is held to the
+ * oracle. An agent carries the axiom through its held role's
  * engineering-principles, never through this block. The apex seed: the
  * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
  * is contingent on this workspace.

package/dist/genus/prime-principle.js

@@ -3,7 +3,10 @@ import { cratylism } from '../dimensions/engineering-principles/cratylism.js';
  * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
  * as the first section of a SKILL.md, set as `preamble` on exactly the skills
  * whose laws apply it: those that name concepts by anchor, optimal sign or cold
- * decode. An agent carries the axiom through its held role's
+ * decode. The axiom's scope is the corpus's core agent dimension names and
+ * values, the terminology the cold-decode oracle was built to discover; every
+ * other term is the industry's own, and no consumer surface is held to the
+ * oracle. An agent carries the axiom through its held role's
  * engineering-principles, never through this block. The apex seed: the
  * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
  * is contingent on this workspace.

package/dist/genus/prime-principle.js.map

@@ -1 +1 @@
-{"version":3,"file":"prime-principle.js","sourceRoot":"","sources":["../../src/genus/prime-principle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;;EAE5B,SAAS;;sBAEW,CAAC"}
+{"version":3,"file":"prime-principle.js","sourceRoot":"","sources":["../../src/genus/prime-principle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;;EAE5B,SAAS;;sBAEW,CAAC"}

package/dist/hook-cells.js

@@ -3,7 +3,7 @@
 // `hooks.ts` no longer hand-authors a `Hook` nor points at on-disk `.sh` assets —
 // it lifts the harness-substrate cells (via forge's doctrine-free `hookIrOf`) into
 // the forge `Hook` IR the projector serializes into `.claude/settings.json`
-// (claude adapter: `turn.end` → Stop, `subagent.end` → SubagentStop) and carries
+// (claude adapter: `turn.end` → Stop) and carries
 // their VERBATIM worker payloads so the projector stages them under `hooks/<id>/`
 // (no file copy — the bytes come from the cell). Only `harness`-substrate cells
 // register in settings.json, and every surviving cell is one: the corpus's single

package/dist/hook-cells.js.map

@@ -1 +1 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,kDAAkD;AAClD,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,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
@@ -153,6 +154,14 @@ input="$(cat)"
 [ -n "$input" ] || open "the hook received no input"
 command -v jq >/dev/null 2>&1 || open "jq is not installed, so the hook payload cannot be read"
 
+# A GUARD BINDS A PERSONA'S OWN MAIN SESSION AND NO SUBAGENT IT DISPATCHES. A subagent is bounded
+# by what it was handed, judged by its assay and the whole check, and supervised by the main
+# session. Claude Code fires this hook inside a subagent too (settings hooks and the subagent's
+# own front-matter hooks), and there the payload carries \`agent_id\` — present only inside a
+# subagent. A guard that does not bind there is not dark: it exits before it judges and says
+# nothing.
+[ -z "$(printf '%s' "$input" | jq -r '.agent_id // empty' 2>/dev/null || true)" ] || allow
+
 # The sibling Stop hook's deployed dir owns the SHARED judge backend, resolved from
 # this script's own location exactly as the pre-hook resolves it — every hooks root
 # holds the hook dirs as siblings, so this derivation is true at every site this file
@@ -197,6 +206,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 +231,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJb,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
@@ -49,7 +50,8 @@ export const stanceGuardrailPre = {
 #   - AskUserQuestion : a permission / option-menu on an in-remit reversible call
 #   - Agent/SendMessage : a dispatch transcribing literal words without extracted intent
 # WHAT IT DOES NOT DENY (reserved): an irreversible-outward consent menu, a true INTENT
-#   ambiguity, a substantive intent-extracted dispatch.
+#   ambiguity, a substantive intent-extracted dispatch, a unit or a closed plan routed by name (the
+#   intent lives in the spec at that address).
 #
 # SAFETY MODEL (mirrors stance-guardrail):
 #   - SCOPE-ENROLLED, exactly as its twin: a scope carrying a stance manifest is judged and
@@ -64,8 +66,8 @@ export const stanceGuardrailPre = {
 #     identical call goes through unjudged, and says so.
 #   - OBSERVABLE. Every notice is also a line in the miss log.
 #
-# INPUT  : Claude Code PreToolUse hook JSON on stdin (tool_name, tool_input, agent_type
-#          [subagents], session_id, cwd, ...).
+# INPUT  : Claude Code PreToolUse hook JSON on stdin (tool_name, tool_input, agent_type,
+#          session_id, cwd, ...).
 # OUTPUT : on collapse -> stdout
 #          {"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny",
 #           "permissionDecisionReason":"..."}} + exit 0.
@@ -134,6 +136,14 @@ input="$(cat)"
 [ -n "$input" ] || open "the hook received no input"
 command -v jq >/dev/null 2>&1 || open "jq is not installed, so the hook payload cannot be read"
 
+# A GUARD BINDS A PERSONA'S OWN MAIN SESSION AND NO SUBAGENT IT DISPATCHES. A subagent is bounded
+# by what it was handed, judged by its assay and the whole check, and supervised by the main
+# session. Claude Code fires this hook inside a subagent too (settings hooks and the subagent's
+# own front-matter hooks), and there the payload carries \`agent_id\` — present only inside a
+# subagent. A guard that does not bind there is not dark: it exits before it judges and says
+# nothing.
+[ -z "$(printf '%s' "$input" | jq -r '.agent_id // empty' 2>/dev/null || true)" ] || allow
+
 # The sibling Stop hook's deployed dir owns the SHARED judge + rubric (deployed
 # together, as siblings under the SAME hooks root).
 #
@@ -180,6 +190,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 +205,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 +219,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)"
@@ -247,8 +265,8 @@ feedback="STANCE GUARDRAIL (pre) — denied this $tool_name call: it collapses o
 intent-driven-expert stance. $reason  Own the in-remit reversible call yourself instead of handing the \\
 operator a menu; extract and serve the underlying INTENT instead of transcribing literal words into a \\
 dispatch. Decide, note the call for review, and proceed. (Legitimate exceptions that should NOT be a menu \\
-here: a genuine irreversible-outward consent choice, a true INTENT ambiguity for /elicit, or a substantive \\
-intent-extracted dispatch.)"
+here: a genuine irreversible-outward consent choice, a true INTENT ambiguity for /elicit, a substantive \\
+intent-extracted dispatch, or a unit or a closed plan routed by name, whose intent lives in its spec.)"
 
 jq -cn --arg r "$feedback" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'
 exit 0

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsJb,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;