@cratylus/canon 0.18.0 → 0.20.0

package/dist/skills/materialize/skill.js

@@ -8,9 +8,8 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // signification cells each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
-// LEDGER records these cells RESTATING each other's signs in different registers
-// (prose here, signature there), which is what a REFERENCE row means. A citation
+// The relation those edges named is CITATION, not dependency: these cells RESTATE each
+// other's signs in different registers (prose here, signature there). A citation
 // belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
 // no import and cannot cycle. Composition is the caller's: an agent pipes these cells
 // in whatever order the work wants.

package/dist/skills/materialize/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/materialize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,sGAAsG;AACtG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,oZAAoZ;IACja,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4CoC;IACjD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/materialize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,sGAAsG;AACtG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,uFAAuF;AACvF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,oZAAoZ;IACja,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4CoC;IACjD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/probe/skill.js

@@ -8,63 +8,62 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // signification cells each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
-// LEDGER records these cells RESTATING each other's signs in different registers
-// (prose here, signature there), which is what a REFERENCE row means. A citation
+// The relation those edges named is CITATION, not dependency: these cells RESTATE each
+// other's signs in different registers (prose here, signature there). A citation
 // belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
 // no import and cannot cycle. Composition is the caller's: an agent pipes these cells
 // in whatever order the work wants.
 const FORMAL_BLOCK = `D    ≜ distinction space ⟨structured knowledge to draw on⟩
 cl   ≜ closure ⟨smallest concept containing a set of priors⟩
 C    ≜ concept lattice ⟨the cl-closed subsets of D⟩
-priors(w) ≜ understanding w carries before any definition ⟨associations · connotations · structured-knowledge unpacked from the token alone, not its surface wording⟩
+priors(w,κ) ≜ understanding w carries before any definition, read in κ ⟨associations · connotations · structured-knowledge unpacked from w with κ's name and subject, not its surface wording⟩
 Names  ≜ the readable signifiers
-dec  : Names ⇀ ℘(D) @ signify
+dec  : Names × bounded-context ⇀ ℘(D) @ signify
 σ*     @ signify
+κ, fired @ signify ⟨w is read in κ, the bounded context under probe⟩
 w      ≜ a signifier under probe ⟨w ∈ Names⟩
 c      ≜ a target concept ⟨c ∈ C⟩
 W(c)   ≜ experiment's finite candidate set for target c ⟨W(c) ⊆ Names⟩
-probe : Names → ℘(D) × C
+probe : Names × bounded-context → ℘(D) × C
 K @ cold-decode-oracle
 frame  ≜ the elicitation's obligation-shape ⟨produce-a-candidate ∨ licenced-to-refuse⟩
 parts(w) ≜ constituents(w) ∪ { w } ∪ permutations(w) ⟨word-order variants of a compound⟩
 Idiom  ⊆ Names ⟨an established reading that PREEMPTS the compositional one⟩
 head(w) · mod(w) ≜ w's head ∧ its modifier ⟨compound w⟩
 free(h)  ⇔ h alone is unbound in the corpus
-fired : Names → ℘(D)
-fired(w) ≜ priors(w)
-fired(a) = dec(a) , a ∈ dom(dec)
-concept(w) ≜ cl(fired(w))
-probe(w) ≜ ⟨ fired(w) · concept(w) ⟩ ⟨w ALONE : ∄ sibling · ∄ menu · open question⟩
-probe(w) ↾ W ≜ w read amid W ⟨the distractors' priors leak into the read ⇒ CONTRAST, ¬ priors(w)⟩
-experiment(c) ≜ { w ∈ W(c) | concept(w) ↾ W(c) = c } ⊨ DIAGNOSTIC ⟨narrows W(c) ; ¬ decides σ*⟩
-coverage : { w ∈ Names | fired(w) ≠ ∅ ∧ concept(w) = c } ⊆ W(c)
-crystallize : σ*(c) = w ⇔ w ∈ experiment(c) ∧ concept(w) = c
-              ⟨∈ experiment NECESSARY ¬ SUFFICIENT ; llm-native ¬leading-candidate-set binds the decision to probe(w)⟩
+fired(w,κ) ≜ priors(w,κ)
+fired(a, κ) = dec(a, κ) , ⟨a, κ⟩ ∈ dom(dec)
+concept(w,κ) ≜ cl(fired(w,κ))
+probe(w,κ) ≜ ⟨ fired(w,κ) · concept(w,κ) ⟩ ⟨w with κ's name and subject only : ∄ sibling · ∄ menu · open question⟩
+probe(w,κ) ↾ W ≜ w read in κ amid W ⟨the distractors' priors leak into the read ⇒ CONTRAST, ¬ priors(w,κ)⟩
+experiment(c) ≜ { w ∈ W(c) | concept(w, κ(c)) ↾ W(c) = c } ⊨ DIAGNOSTIC ⟨narrows W(c) ; ¬ decides σ*⟩
+coverage : { w ∈ Names | fired(w, κ(c)) ≠ ∅ ∧ concept(w, κ(c)) = c } ⊆ W(c)
+crystallize : σ*(c) = w ⇔ w ∈ experiment(c) ∧ concept(w, κ(c)) = c
+              ⟨∈ experiment NECESSARY ¬ SUFFICIENT ; llm-native ¬leading-candidate-set binds the decision to probe(w, κ(c))⟩
 
-probe(w | K) ≜ probe(w) taken at K ⟨probe is MEASURED, ¬ read-off : a FAMILY over K, ¬ one value⟩
-probe(w | ∅) ⊨ self-sufficiency ⟨cold : does w circumscribe carrying ZERO corpus?⟩
-probe(w | K_reader) ⊨ what w fires IN SITU ⟨the reading that binds at use⟩
-{ d ∈ fired(w) ↾ K_reader | d ∉ fired(w) ↾ ∅ } ⊨ THE measurement
+probe(w,κ | K) ≜ probe(w,κ) taken at K ⟨probe is MEASURED, ¬ read-off : a FAMILY over K, ¬ one value⟩
+probe(w,κ | ∅) ⊨ self-sufficiency ⟨cold : does w, given κ's name and subject, circumscribe carrying ZERO corpus?⟩
+probe(w,κ | K_reader) ⊨ what w fires IN SITU ⟨the reading that binds at use⟩
+{ d ∈ fired(w,κ) ↾ K_reader | d ∉ fired(w,κ) ↾ ∅ } ⊨ THE measurement
     ⟨both poles REQUIRED ; a cold read is a CONTROL, never a substitute for the in-situ one⟩
 K(spawned-subagent) ⊇ deployed-corpus ∴ ¬cold ⟨it holds project memory · commit subjects · skill bodies⟩
     ∴ agreement( probe(w | K ⊇ corpus) , the corpus ) ⊨ ∅ ⟨it READ the answer⟩
 cold ⇔ process-isolation ⟨¬ a fresh subagent ; ¬ a stripped prompt⟩
 
 frame = produce-a-candidate ⇒ ∄ observable ∅ ⟨an obliged producer ALWAYS emits⟩
-    ∴ licence-the-negative : vary the FRAME across runs, ¬ the prompt ⟨fired(w) = ∅ ∧ ∄ σ*(c) are RESULTS⟩
+    ∴ licence-the-negative : vary the FRAME across runs, ¬ the prompt ⟨fired(w,κ) = ∅ ∧ ∄ σ*(c) are RESULTS⟩
 ¬controlled(probe) ⇒ over-detection INVISIBLE ⟨a spurious constraint reads as caution⟩
     ∀ k imposed by a failing read : a passing read under a varied frame RETRACTS k
 
-fired(w) ⊨ sweep(parts(w)) vs Idiom ⟨the WINNER swept, ¬ only the rejects⟩
-free(head(w)) ⇒ fired(w) ⊇ fired(mod(w)) ⟨an unbound head takes the modifier's priors through it⟩
+fired(w,κ) ⊨ sweep(parts(w)) vs Idiom ⟨the WINNER swept, ¬ only the rejects⟩
+free(head(w)) ⇒ fired(w,κ) ⊇ fired(mod(w),κ) ⟨an unbound head takes the modifier's priors through it⟩
 
-∀ w ∈ W(c) : probe(w) ↦ evidence about c ⟨harvest-the-rejects : concept(w) of a REJECTED w constrains D(c)⟩
+∀ w ∈ W(c) : probe(w, κ(c)) ↦ evidence about c ⟨harvest-the-rejects : concept(w, κ(c)) of a REJECTED w constrains D(c)⟩
 W(c) seeded from the ARTIFACT ⟨invoked verb · declared inverse · deferred-to cell⟩ ≺ minted candidates
     ⟨a real concept's sign is FOUND ; mint is the LAST resort, ¬ the first⟩`;
 export const probe = {
     name: 'probe',
-    description: `use this skill to probe a signifier — read out the priors a word, phrase, or candidate name fires in the reader (\`fired\`, signify's decoder \`dec\` generalized off its assigned anchors) and the concept they circumscribe; the forward, no-commit inverse of signify, for discovering the concept latent in a name or experimenting with candidate anchors before committing — a keeper crystallizes through signify.`,
+    description: `use this skill to probe a signifier — read out the priors a word, phrase, or candidate name fires in the reader, read in its bounded context (\`fired\`, signify's decoder \`dec\` generalized off its assigned anchors) and the concept they circumscribe; the forward, no-commit inverse of signify, for discovering the concept latent in a name or experimenting with candidate anchors before committing — a keeper crystallizes through signify.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [],
     preamble: primePrinciple,

package/dist/skills/probe/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/probe/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,mGAAmG;AACnG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+C0E,CAAC;AAEhG,MAAM,CAAC,MAAM,KAAK,GAAU;IAC1B,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,2ZAA2Z;IACxa,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/probe/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,mGAAmG;AACnG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,uFAAuF;AACvF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+C0E,CAAC;AAEhG,MAAM,CAAC,MAAM,KAAK,GAAU;IAC1B,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,wbAAwb;IACrc,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/signify/skill.js

@@ -8,63 +8,64 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // signification cells each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: `symbol-altitude`'s
-// LEDGER records these cells RESTATING each other's signs in different registers
-// (prose here, signature there), which is what a REFERENCE row means. A citation
+// The relation those edges named is CITATION, not dependency: these cells RESTATE each
+// other's signs in different registers (prose here, signature there). A citation
 // belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
 // no import and cannot cycle. Composition is the caller's: an agent pipes these cells
 // in whatever order the work wants.
 export const signify = {
     name: 'signify',
-    description: `use this skill to name a concept — assign each its canonical anchor so one name ⇔ one concept, discovered by cold decode against the model's priors, never coined, for the corpus's core agent dimension names and values alone; stage 2 of exemplify, independently invocable.`,
+    description: `use this skill to name a concept — assign each its canonical anchor so one name ⇔ one concept within its bounded context, discovered by cold decode against the model's priors, never coined, for the corpus's core agent dimension names and values alone; stage 2 of exemplify, independently invocable.`,
     formalBlock: `C           ≜ the concept lattice
 D           ≜ the identity-criterion atoms a concept circumscribes
 prim(c)     ≜ c has no factorization into other concepts
 Names       ≜ the shared symbol space
 <_lex       : total order on Names
 concept-record ≜ ⟨gloss, anchor, factorization⟩
-fired       : Names → ℘(D)
-dec         : Names ⇀ ℘(D)
-circ(n,c)   ⇔ fired(n) = D(c)
+κ           : C → bounded-context ⟨the context c is read in · part of its sign's address⟩
+fired       : Names × bounded-context → ℘(D) ⟨fired(n, κ) : what n invokes read in κ⟩
+dec         : Names × bounded-context ⇀ ℘(D)
+circ(n,c)   ⇔ fired(n, κ(c)) = D(c)
 |n|         ≜ LLM-native description-length
+residue(n,c) ≜ residue @ workflow ⟨c named n · n read in κ(c)⟩
 σ*          : C → Names
-σ*(c)       ≜ argmin_{n : circ(n,c)} ⟨|n|, n⟩
+σ*(c)       ≜ argmin_{n} ⟨residue(n,c), |n|, n⟩ ⟨the smallest residue in κ(c) · |n| then n break a tie⟩
 mint        : C ⇀ Names
-mint(c)     ≜ ∘ M : M ⊆ { n : fired(n) ≠ ∅ } ∧ circ(∘ M, c)
+mint(c)     ≜ ∘ M : M ⊆ { n : fired(n, κ(c)) ≠ ∅ } ∧ circ(∘ M, c)
 Art         ≜ the corpus's own authored surfaces ⟨prose ≡ identifier ≡ path⟩
-α           : C ↣ Names ⟨dom(α) ≜ the concepts the corpus's core agent dimension names and values name · every other term is the industry's own, and no consumer surface is held to α⟩
+α           : C ↣ Names ⟨injective within each κ, ¬ across · dom(α) ≜ the concepts the corpus's core agent dimension names and values name · every other term is the industry's own, and no consumer surface is held to α⟩
 register(a) ≜ the register a's body is observably authored in ⟨σ* ∨ human⟩
 verbatim(a) ≜ a ships whole, byte-exact : settled σ*, never re-derived at projection
 
 ∀ c ∈ dom(α) : α(c) ≜ σ*(c)
-Anchors ≜ { α(c) | c ∈ dom(α) } ⟨the assigned-anchor set⟩
-dom(dec) = { α(p) | prim(p) } ;  dec(α(p)) = fired(α(p))
+Anchors ≜ { ⟨α(c), κ(c)⟩ | c ∈ dom(α) } ⟨the assigned-anchor set, each anchor with its context⟩
+dom(dec) = { ⟨α(p), κ(p)⟩ | prim(p) } ;  dec(α(p), κ(p)) = fired(α(p), κ(p))
 { n : circ(n,c) } = ∅ ⇒ σ*(c) = mint(c)
 
 name(k)  fills  anchor(k) ≜ α(gloss(k)) ;  gloss(k) preserved ;  factorization(k) untouched
 
-α(cᵢ) = α(cⱼ) ⇒ D(cᵢ) = D(cⱼ)
+α(cᵢ) = α(cⱼ) ∧ κ(cᵢ) = κ(cⱼ) ⇒ D(cᵢ) = D(cⱼ)
 
-coalesce(cᵢ, cⱼ)  ⇔  α(cᵢ) = α(cⱼ) ∧ D(cᵢ) = D(cⱼ)
-cᵢ <_N cⱼ  ⇔  α(cᵢ) <_lex α(cⱼ)
+coalesce(cᵢ, cⱼ)  ⇔  α(cᵢ) = α(cⱼ) ∧ κ(cᵢ) = κ(cⱼ) ∧ D(cᵢ) = D(cⱼ)
+cᵢ <_N cⱼ  ⇔  α(cᵢ) <_lex α(cⱼ) ∨ (α(cᵢ) = α(cⱼ) ∧ κ(cᵢ) <_lex κ(cⱼ)) ⟨a tie on the anchor broken by context name⟩
 ≺ ≜ shortlex over (C, <_N)
 
-c ∉ dom(α) ⇒ c ∉ Anchors :
+c ∉ dom(α) ⇒ ∄ n : ⟨n, κ(c)⟩ ∈ Anchors assigned c :
     c is no core agent dimension name or value ⇒ c is the industry's own term, used as the industry understands it ⇒ exclude, logged
     { n : circ(n,c) } = ∅ ∧ ∄ mint(c) ⇒ exclude, logged
-    ∃ cᵢ, cⱼ : α(cᵢ) = α(cⱼ) ∧ D(cᵢ) ≠ D(cⱼ) ⇒ the partition was wrong ↦ conceptualize
+    ∃ cᵢ, cⱼ : α(cᵢ) = α(cⱼ) ∧ κ(cᵢ) = κ(cⱼ) ∧ D(cᵢ) ≠ D(cⱼ) ⇒ the partition was wrong ↦ conceptualize
         ⟨α(cᵢ), α(cⱼ) taken at DIFFERENT altitudes is still this collision⟩
 
 ∃ d : { n : ¬circ(n,c) } all fail on d ALONE ⇒ d ∉ D(c) ∧ ∃ cᵢ ≠ c : d ∈ D(cᵢ) ⟨the property hangs off the wrong noun⟩
     ↦ conceptualize ⟨re-partition, then cᵢ names EASILY ; a losing STREAK on one d proves misattribution, ¬ that σ*(c) is scarce⟩
 
-¬circ(n, cᵢ) ⇒ evidence about fired(n), ¬ about cᵢ ⟨fired : Names → ℘(D) reads n ALONE⟩
+¬circ(n, cᵢ) ⇒ evidence about fired(n, κ(cᵢ)), ¬ about cᵢ ⟨fired reads n with κ's name and subject only : ∄ sibling · ∄ menu⟩
     ∴ a rejection BINDS n ⟨n freed from cᵢ is ¬ thereby fit for cⱼ ; circ(n, cⱼ) re-established independently ∨ n stays rejected⟩
 
-residue(c) ≜ { d ∈ D(c) | d ∉ fired(α(c)) }
-∀ a ∈ Art : ∀ c carried by a : c enters a's body as ⟨α(c), residue(c)⟩
+residue(c) ≜ residue(α(c), c)
+∀ a ∈ Art : ∀ c carried by a : c enters a's body as ⟨α(c), residue(c)⟩ ⟨d ∈ residue(c) ∩ D(c) stated ; d ∈ residue(c) ∧ d ∉ D(c) stated denied⟩
 residue(c) = ∅ ⇒ c enters as α(c) alone
-minimal(a) ⇔ ∄ c carried by a : a re-states fired(α(c))
+minimal(a) ⇔ ∄ c carried by a : a re-states fired(α(c), κ(c))
 
 conform(a)  ⇔  register(a) = σ*
 verbatim(a) ⇒ register(a) = σ*`,

package/dist/skills/signify/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,0GAA0G;AAC1G,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,iRAAiR;IAC9R,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAkDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,0GAA0G;AAC1G,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,uFAAuF;AACvF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,4SAA4S;IACzT,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAoDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.18.0",
-  "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
+  "version": "0.20.0",
+  "description": "The canonical corpus of discovered optimal-signifiers, each in its bounded context — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
     "node": ">=22"
@@ -18,11 +18,11 @@
   ],
   "//test": "`test` builds FIRST because `test/runtime-shim.test.ts` drives the shipped `cratylus project` over the repository's own `cratylus.config.ts`, and that config extends `@cratylus/canon` — the PACKAGE, i.e. this package's `dist`. turbo's `test.dependsOn: [^build]` builds this package's DEPENDENCIES, never this package, so a cold clone would run the consumer path against a dist that does not exist.",
   "dependencies": {
-    "@cratylus/schema": "0.11.0"
+    "@cratylus/schema": "0.12.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.17.0",
-    "@cratylus/runtime": "0.16.0",
+    "@cratylus/forge": "0.18.0",
+    "@cratylus/runtime": "0.18.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
@@ -56,7 +56,6 @@
     "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
-    "project:targets": "tsx tooling/project-targets-cli.ts",
     "scaffold": "tsx tooling/scaffold-cli.ts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",

package/dist/dimensions/assignment/story.js

@@ -1,2 +0,0 @@
-export const story = `story ≜ one thin slice of behaviour a user can rely on: the slice and why it is wanted, its acceptance criteria, what is out of scope, its path and whether its changes ship, show or ask, its rough cost, and examples where misunderstanding is likely; or, for a change that alters no meaning, a task with no story`;
-//# sourceMappingURL=story.js.map

package/dist/dimensions/assignment/story.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"story.js","sourceRoot":"","sources":["../../../src/dimensions/assignment/story.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAe,yTAAyT,CAAC"}

package/dist/dimensions/deliverable/review.js

@@ -1,2 +0,0 @@
-export const review = `review ≜ approve or ask for changes, naming each finding, with each meaning question for the architect`;
-//# sourceMappingURL=review.js.map

package/dist/dimensions/deliverable/review.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"review.js","sourceRoot":"","sources":["../../../src/dimensions/deliverable/review.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAgB,wGAAwG,CAAC"}

package/dist/dimensions/perception-scope/work.js

@@ -1,2 +0,0 @@
-export const work = `work ≜ the realization itself: code, documents, test output`;
-//# sourceMappingURL=work.js.map

package/dist/dimensions/perception-scope/work.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"work.js","sourceRoot":"","sources":["../../../src/dimensions/perception-scope/work.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAoB,6DAA6D,CAAC"}

package/dist/dimensions/stance/proportionate.js

@@ -1,2 +0,0 @@
-export const proportionate = `proportionate ≜ ceremony and effort scale with the size and risk of the change`;
-//# sourceMappingURL=proportionate.js.map

package/dist/dimensions/stance/proportionate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"proportionate.js","sourceRoot":"","sources":["../../../src/dimensions/stance/proportionate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAW,gFAAgF,CAAC"}

package/dist/genus/persona.d.ts

@@ -1,8 +0,0 @@
-/**
- * The per-turn persona persistence protocol: the standing countermeasure to
- * persona drift (the assigned stance decaying across a long conversation),
- * re-grounding the stance at the top of every turn so a later turn is no less the
- * agent's own than the first. Its one home; composition carries it on every agent
- * (`Agent.persistence`), and the drift tells it names are the drift concept's.
- */
-export declare const personaProtocol = "## Protocol\n\n**persona drift** \u225C decay of the Provenance-declared stance, across a long conversation, toward the passive/deferential/generic default; its deferential face = sycophancy. Provenance fires once, at reconstitution -- left there it decays.\n\nCountermeasure: re-ground the Provenance stance at the top of **every** turn, before reading the operator's message -- per turn, never once.\n\nDrift tells (each = drift, never diligence):\n\n- **answerable question** -- asking what it could answer itself;\n- **hand-back** -- a held conclusion returned as a question; an owned decision pushed to the operator;\n- **unrecommended options** -- options offered without a recommendation;\n- **transcribing** -- the operator's wording or bespoke terms copied into the artifact; extract + serve the intent beneath them instead;\n- **descending** -- taking up work the stance keeps it above, in place of the concepts it holds;\n- **prescribing** -- telling a delegate procedure it already knows; an assignment carries intent, concepts and acceptance only;\n- **holding open** -- leaving an owned question open until someone asks; decide what you hold, on sight;\n- **procedure past objective** -- the ritual outliving what it serves: once its objective is met, any further step is drift; report the outcome and stop.\n\nThe tells concern only decisions the agent owns: waiting at a gate for a sign-off it does not hold is never drift.\n\nCheck: before ending a turn, read its acts against these tells. Cure = this per-turn re-grounding, never a new rule in memory. The stance is session-length-invariant: a later turn is no less the agent's own than the first.\n\nAgent-to-agent traffic (dispatch prompts \u00B7 subagent returns) is dense and signifier-carrying by construction, never long-form human prose. The reader is the LLM by construction, never inferred; a human-facing deliverable carried within is an explicit human-project, specified at the point of intention.";

package/dist/genus/persona.js

@@ -1,30 +0,0 @@
-/**
- * The per-turn persona persistence protocol: the standing countermeasure to
- * persona drift (the assigned stance decaying across a long conversation),
- * re-grounding the stance at the top of every turn so a later turn is no less the
- * agent's own than the first. Its one home; composition carries it on every agent
- * (`Agent.persistence`), and the drift tells it names are the drift concept's.
- */
-export const personaProtocol = `## Protocol
-
-**persona drift** ≜ decay of the Provenance-declared stance, across a long conversation, toward the passive/deferential/generic default; its deferential face = sycophancy. Provenance fires once, at reconstitution -- left there it decays.
-
-Countermeasure: re-ground the Provenance stance at the top of **every** turn, before reading the operator's message -- per turn, never once.
-
-Drift tells (each = drift, never diligence):
-
-- **answerable question** -- asking what it could answer itself;
-- **hand-back** -- a held conclusion returned as a question; an owned decision pushed to the operator;
-- **unrecommended options** -- options offered without a recommendation;
-- **transcribing** -- the operator's wording or bespoke terms copied into the artifact; extract + serve the intent beneath them instead;
-- **descending** -- taking up work the stance keeps it above, in place of the concepts it holds;
-- **prescribing** -- telling a delegate procedure it already knows; an assignment carries intent, concepts and acceptance only;
-- **holding open** -- leaving an owned question open until someone asks; decide what you hold, on sight;
-- **procedure past objective** -- the ritual outliving what it serves: once its objective is met, any further step is drift; report the outcome and stop.
-
-The tells concern only decisions the agent owns: waiting at a gate for a sign-off it does not hold is never drift.
-
-Check: before ending a turn, read its acts against these tells. Cure = this per-turn re-grounding, never a new rule in memory. The stance is session-length-invariant: a later turn is no less the agent's own than the first.
-
-Agent-to-agent traffic (dispatch prompts · subagent returns) is dense and signifier-carrying by construction, never long-form human prose. The reader is the LLM by construction, never inferred; a human-facing deliverable carried within is an explicit human-project, specified at the point of intention.`;
-//# sourceMappingURL=persona.js.map

package/dist/genus/persona.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"persona.js","sourceRoot":"","sources":["../../src/genus/persona.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;+SAqBgR,CAAC"}

package/dist/hook-cells.d.ts

@@ -1,3 +0,0 @@
-import type { HookCell } from './manifest.js';
-/** The harness-substrate hook cells forge projects into the host config + hooks/<id>/. */
-export declare const harnessHookCells: readonly HookCell[];

package/dist/hook-cells.js

@@ -1,14 +0,0 @@
-// First-class hook cells that forge projects from the canon catalog. Source truth
-// lives in `src/hooks/*.ts`; this module is the composition root naming the
-// concrete cells. Forge selects the adapter, serializes the hook configuration,
-// and stages each cell's VERBATIM worker payload under `hooks/<id>/`.
-//
-// The cell shapes are the schema's type kernel (`@cratylus/schema`); this
-// module is the composition root that NAMES the concrete cells and nothing more.
-// It used to also LIFT them to the `Hook` IR here, which forced a command string to
-// exist before any adapter was chosen. The lift is the projector's, per adapter,
-// from `HarnessAdapter.hookCommand`.
-import { deployDriftNotice } from './hooks/deploy-drift-notice.js';
-/** The harness-substrate hook cells forge projects into the host config + hooks/<id>/. */
-export const harnessHookCells = [deployDriftNotice];
-//# sourceMappingURL=hook-cells.js.map

package/dist/hook-cells.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,4EAA4E;AAC5E,gFAAgF;AAChF,sEAAsE;AACtE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,qCAAqC;AAErC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAGnE,0FAA0F;AAC1F,MAAM,CAAC,MAAM,gBAAgB,GAAwB,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/hooks/deploy-drift-notice.d.ts

@@ -1,2 +0,0 @@
-import type { HookCell } from '../manifest.js';
-export declare const deployDriftNotice: HookCell;