@cratylus/canon 0.8.0 → 0.10.0

package/dist/skills/design/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 // THE DURATIVE HALF. `plan` and `deliver` are per-effort; this cell is the one that
 // persists across every effort, and that asymmetry is the whole point of the trio.
 //
@@ -11,7 +12,7 @@
 //
 // The second reason is verification. Acceptance keyed to a work-unit's own criteria
 // is a CLOSED loop — the unit is graded against its own account of itself, so an
-// executor that satisfies the letter passes while the system stays incoherent. A
+// implementer that satisfies the letter passes while the system stays incoherent. A
 // second, independent statement of what should exist is what makes validation an
 // operation rather than a re-reading of the claim. That statement is this lattice.
 const FORMAL_BLOCK = `anchor ≜ a concept's canonical sign @ signify
@@ -26,8 +27,8 @@ closure : C → ℘(C) ⟨closure(c) ≜ { c } ∪ ⋃ { closure(f) | f ∈ fact
 denotes : anchor ⇀ C
 σ*      @ signify
 conform @ signify
-Piece  ≜ a cut piece ⟨what a planner is handed⟩
-cut    : C → ℘(℘(C))
+shard(c) ≜ ⟨ c , closure(c) ⟩ handed down ⟨what a planner is handed · one concept with everything it stands on⟩
+cut    ≜ the architect's choice of shards to hand the planner
 history(c) ≜ every version ∧ retraction of c, in order ⟨resident · ¬ deleted⟩
 settled(c) ⇔ c has exactly one current version
 live(c) ⇔ settled(c) ∧ that version ¬ a retraction
@@ -67,20 +68,29 @@ reconcile ⊨ self ⟨reconciliation of the design is the architect's alone⟩
 planner ∨ implementer ∨ assayer ⊨ diverged ∨ incoherent ⇒ report ∧ ¬ resolve
 blast(c) ≜ { d ∈ C | c ∈ closure(d) } ⟨DERIVED, ¬ guessed · what the normal form buys⟩
 churn(primitive) high ⇒ conceptualization wrong ⟨primitives near-stable · composites move⟩
-⋃ cut(C) = C ∧ ∀ s₁, s₂ ∈ cut(C) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
-∀ s ∈ cut(C) : ∀ c ∈ s : closure(c) ⊆ s ⟨a piece is CLOSED ∴ plannable alone⟩
-cut ⊨ self ⟨the ASSIGNMENT of concepts to pieces is the design-holder's ; a planner
-    receiving a piece may ¬ redraw it · a boundary it cannot plan is SURFACED⟩
-yield ≠ ∅ ⇒ amend(C) ⟨intake at INCEPTION ∧ live, never at retirement : an obligation
-    standing between an agent and closing its work always loses · measured 0 of 25⟩
+shard(c) states what must hold ∧ why ∧ ¬ how ⟨how a harness or a codebase achieves it is the plan's⟩
+a quirk met while realizing shard(c) ⇒ the planner's ∧ the implementer's to solve ∧ ¬ a reason to amend(c)
+cut ⊨ self ⟨the CHOICE of shards is the design-holder's ; a planner receiving a shard may
+    ¬ redraw it · a boundary it cannot plan is SURFACED⟩
+yield ≠ ∅ ⇒ a hypothesis self rectifies against its expertise ∧ the field's practice, ¬ a fact to copy into C ⟨every input,
+    the operator's included, and every delegate's finding, which reaches self as a note⟩ ; a survivor
+    bearing on the bound plan ⇒ capture a decision note on the topic of its concept, blocking nothing, ∧
+    amend(C) when that plan completes, for a following plan sequenced after the work it depends on ; any other survivor ⇒ amend(C) at once
+the bound plan ⟨C is its fixed target : a held change never amends a shard under a running plan⟩ ; a change bears on it
+    ⇔ its concept is a shard the plan realizes ∨ stands in the closure of one
+the bound plan found built on a shard c that is itself wrong ⇒ in order ⟨self captures a note blocking that plan ;
+    self amend(c) once ; the planner re-plans, rectifying or rebuilding ; self retracts the note ; work resumes⟩
+    ⟨intake at INCEPTION ∧ live, never at retirement : the note is the intake, captured at once ; only the
+     amend waits · an obligation standing between an agent and closing its work always loses · measured 0 of 25⟩
 design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
     fragments BY CONSTRUCTION⟩
 design ≜ conceptualize(intent) → signify(·) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
 export const design = {
     name: 'design',
-    description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into closed pieces a planner can take. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution establishes something the model does not yet hold. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the executor's own claim.`,
+    description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into shards a planner can take, each stating what and why, never how. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution or the operator establishes something the model does not yet hold: every such input is a hypothesis the holder rectifies first, and a survivor bearing on a shard a bound plan realizes is held as a note until that plan completes while any other is amended at once, and a plan found built on a wrong shard stops until the shard is corrected once and the plan re-planned. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the implementer's own claim.`,
     formalBlock: FORMAL_BLOCK,
     runtime: { capability: 'design' },
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,mFAAmF;AACnF,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,iFAAiF;AACjF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGA6DmG,CAAC;AAEzH,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wsBAAwsB;IACrtB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/design/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,oFAAoF;AACpF,mFAAmF;AACnF,EAAE;AACF,kFAAkF;AAClF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,mFAAmF;AAEnF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAqEmG,CAAC;AAEzH,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wiCAAwiC;IACrjC,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;IACjC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/exemplify/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 // COMPOSES NOTHING, and that is the repair.
 //
 // This cell used to declare `composition: () => [conceptualize, signify, materialize]` and import those
@@ -50,5 +51,6 @@ export const exemplify = {
     description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept; emits the R3 routing manifest that catches the dropped idea.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/formalize/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 import { conceptualize } from '../conceptualize/skill.js';
 import { signify } from '../signify/skill.js';
 export const formalize = {
@@ -31,5 +32,6 @@ gloss(B) ≜ prose of B beyond β ∪ ι ; gloss(B) ≠ ∅ ⇒ ¬complete(B)
 reconstruct(B) ≽ prose
 reconstruct(B) ⋡ prose ⇒ ⊥`,
     composition: () => [conceptualize, signify],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,kYAAkY;IAC/Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0B+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;CAC5C,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,kYAAkY;IAC/Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0B+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/introspect/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 export const introspect = {
     name: 'introspect',
     description: `use this skill when an agent needs to self-audit — compare each dimension's defined value against the value actually in effect this session, and name the cause of every divergence.`,
@@ -47,5 +48,6 @@ why(o) ∈ K_cfg            ⇒ reconcile @ { create-agent · deploy }
 why(o) = misnomer         ⇒ reconcile @ signify ≺ { create-agent · deploy }
 O · causes        @ live-anatomy`,
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/introspect/skill.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAU;IAC/B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,sLAAsL;IACnM,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA4CqC;IAClD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/introspect/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,MAAM,CAAC,MAAM,UAAU,GAAU;IAC/B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,sLAAsL;IACnM,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA4CqC;IAClD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/materialize/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 // COMPOSES NOTHING, and that is the repair.
 //
 // This cell used to declare `composition: () => [exemplify, signify, conceptualize]` and import those
@@ -62,5 +63,6 @@ s unnamed ∨ s ∉ S ⇒ ⊥
     classification ↦ membership test
     utility        ↦ instrument`,
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/materialize/skill.ts"],"names":[],"mappings":"AAEA,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;CACtB,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,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"}

package/dist/skills/plan/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 import { design } from '../design/skill.js';
 import { note } from '../note/skill.js';
 // SUPERSEDES `praxis`, which carried three activities with three different ends —
@@ -17,10 +18,11 @@ import { note } from '../note/skill.js';
 // the roles it names (which plan state at most one plan holds, which is final, which
 // unit state satisfies a dependency), never on a spelling of its own.
 //
-// The laws carried forward are the ones that were PAID FOR. The output-array law and
-// its measurement survive verbatim because the defect it names — a footprint read off
-// where a sign is DEFINED while the work is bounded by where it is USED — recurred six
-// times in one plan and voids every disjointness proof above it when it recurs.
+// The laws carried forward are the ones that were PAID FOR. The output-array law
+// survives because the defect it names — a footprint read off where a sign is DEFINED
+// while the work is bounded by where it is USED — recurred six times in one plan (a
+// declared glob against fifteen written paths among them) and voids every disjointness
+// proof above it when it recurs.
 const LIFECYCLE = {
     plan: {
         states: ['proposed', 'bound', 'closed'],
@@ -30,13 +32,12 @@ const LIFECYCLE = {
     unit: { states: ['pending', 'active', 'completed'], satisfies: 'completed' },
 };
 const { plan: PLAN, unit: UNIT } = LIFECYCLE;
-const FORMAL_BLOCK = `s      ≜ a cut piece ⟨closed · handed down · ¬ redrawable here⟩ @ design
+const FORMAL_BLOCK = `shard  @ design
 c      @ design
 anchor @ design
 closure @ design
 withdrawn @ design
-self   @ design
-P      ≜ a plan : the units cutting s into work
+P      ≜ a plan : the units realizing a set of shards
 unit   ≜ a unit of work ⟨unit ∈ P⟩
 name(x) ≜ the label x is addressed by ⟨x a P ∨ a unit · revisable⟩
 States(P) ≜ { ${PLAN.states.join(', ')} } ⟨in lifecycle order⟩
@@ -64,7 +65,7 @@ accept : P → (return → 𝔹) ⟨MECHANICAL only · the semantic half is @ de
 pre    : P → return
 spec(unit) ≜ ⟨ realizes(unit), intent(unit), static(unit), deps(unit), outputs(unit), accept(unit) ⟩
 census : intent → ⟨scope, static, deps, occurs⟩ ⟨delegable-to agent⟩
-capacity ≜ the effort one executor finishes in one dispatch ⟨DECLARED by the executor's harness · ¬ a constant here⟩
+capacity ≜ the effort one implementer finishes in one dispatch ⟨DECLARED by the implementer's harness · ¬ a constant here⟩
 effort(unit) ≜ what building ∧ proving unit costs ⟨reading included⟩
 slices : P → ℘(℘(P))
 cross(S) ≜ |R ∩ ⋃ { sᵢ × sⱼ | sᵢ, sⱼ ∈ S ∧ i ≠ j }|
@@ -74,35 +75,36 @@ W(n)   ≜ ⋃ { wave(i) | i ≤ n }
 owed   @ note
 blocked(unit) ⇔ ∃ u ∈ deps(unit) : ¬satisfied(u)
 ready(unit) ⇔ bound(P) ∧ ¬blocked(unit) ∧ ∄ owed note blocking unit ∨ P ⟨computed, never stored · ready
-    PROMISES an executor can FINISH · conflating a dep with a ruling stalls a fan-out⟩
+    PROMISES an implementer can FINISH · conflating a dep with a ruling stalls a fan-out⟩
 frontier(P) ≜ { unit | ready(unit) ∧ state(unit) = ${UNIT.states[0]} } ∪ { unit | bound(P) ∧ ${UNIT.states[0]} ≺ state(unit) ≺ ${UNIT.satisfies} } ⟨where
     the plan IS · ¬ only what is dispatchable · ¬bound(P) ⇒ frontier(P) = ∅⟩
-planner   ≜ the planner ⟨bounded to s⟩
+planner   ≜ the planner ⟨bounded to its shards⟩
 conform @ signify
 show(P) ≜ \`scripts/plan.mjs show [<plan>]\` ↦ the bound P in wave order ∨ any P named, whole
-show(unit) ≜ \`scripts/plan.mjs show <unit> --plan <p>\` ↦ one unit in full
+show(unit) ≜ \`scripts/plan.mjs show <unit> --plan <p>\` ↦ one unit in full ⟨the planner's ∧ the implementer's read · ¬ the architect's⟩
 add(unit) ≜ \`scripts/plan.mjs add <unit> --plan <p> --realizes <concept> --intent <i> [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--plan-realizes <concept>]…\` ⟨pin(unit) taken · the first add naming an absent P proposes it, realizing each --plan-realizes⟩
 advance(unit) ≜ \`scripts/plan.mjs advance <unit> --plan <p> --to <state>\`
 retract(unit) ≜ \`scripts/plan.mjs retract <unit> --plan <p>\`
 revise(unit) ≜ \`scripts/plan.mjs revise <unit> --plan <p> [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]…\` ⟨spec(unit) · pin(unit) kept⟩
 revise(P) ≜ \`scripts/plan.mjs revise <plan> [--name <n>] [--realizes <concept>]…\` ⟨name(P) ∨ realizes(P)⟩
-bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P) ∧ the P bound before returns to ${PLAN.states[0]}⟩
+bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P)⟩
 close(P) ≜ \`scripts/plan.mjs close <plan>\` ⟨closed(P)⟩
 reconcile(x) ≜ \`scripts/plan.mjs reconcile <unit> --plan <p> [--name <n>] [--realizes <concept>] [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--state <state>] [--repin]\` ∨ \`scripts/plan.mjs reconcile <plan> [--name <n>] [--realizes <concept>]… [--state <state>]\` ↦ one version superseding every current version of x ⟨each field the versions disagree on is given · a unit whose versions pin differently takes --repin⟩
+land(unit) ≜ \`scripts/plan.mjs land <unit> --plan <p> --commit <c>\`
+assay(unit) ≜ \`scripts/plan.mjs assay <unit> --plan <p> --commit <c> --verdict <achieved|not-achieved> [--missing <part>]…\`
+whole(unit) ≜ \`scripts/plan.mjs whole <unit> --plan <p> --commit <c>\`
+broke(unit) ≜ \`scripts/plan.mjs broke <unit> --plan <p> --check <check>\`
 
-∀ add ∨ advance ∨ retract ∨ revise ∨ bind ∨ close ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
-∀ unit : realizes(unit) ∈ { anchor(c) | c ∈ s } ⟨TOTALITY is the gate · a unit citing no
+∀ verb ≠ show : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
+∀ unit : realizes(unit) = the anchor of ONE shard ⟨TOTALITY is the gate · a unit citing no
     concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
-∀ unit : closure(denotes(realizes(unit))) ⊆ s ⟨a unit reaching outside its piece is a
-    BOUNDARY finding · SURFACE it ; the planner may ¬ redraw the cut⟩
+shard ¬ how ∴ how it is realized on each harness is the plan's
 ∀ unit : realizes(unit) = the concept pin(unit) names ∧ realizes(unit) ∈ realizes(P) ⟨a merge
     breaking it is incoherent(P), reported like the others⟩
 |{ P | bound(P) }| ≤ 1 ⟨held by bind(P), which returns the P bound before⟩
 ∀ n : |{ P | live(P) ∧ name(P) = n }| ≤ 1 ∧ ∀ P : |{ unit ∈ P | live(unit) ∧ name(unit) = n }| ≤ 1
 closed(P) ⇒ name(P) kept ∧ ∄ write to P ∨ any unit ∈ P ⟨closed is final · readable forever⟩
 ¬closed(P) ⇒ revise(P) admitted ⟨its name ∧ its concepts, never its state⟩
-state(P) moves by bind(P) ∨ close(P) alone
-revise routes to revise(unit) ∨ revise(P) by the name it is given ⟨--plan puts a unit's P in view⟩
 ∃ u : live(u) ∧ unit ∈ deps(u) ⇒ ¬ retract(unit)
 advance(unit) ⊨ bound(P) ∧ one step forward in States(unit) ⟨a skip ∨ a step back refuses · a unit of an unbound P is authored ∧ revised, ¬ worked⟩
 ∀ unit : R acyclic ∧ ∀ u ∈ deps(unit) : live(u) ∧ u ∈ P
@@ -112,50 +114,46 @@ pin(unit) retaken ⇔ \`scripts/plan.mjs revise <unit> --plan <p> --repin --reas
 withdrawn(denotes(realizes(unit))) ⇒ drifted(unit) ∧ ¬ incoherent(P) ⟨a retraction in the design never breaks a plan law⟩
 drifted(unit) ∨ suspect(unit) ⇒ SURFACE ⟨the design moved under the plan · drift, ¬ staleness⟩
 drifted(unit) ⇒ response ↾ what moved ⟨nothing ⇒ repin · gloss ⇒ repin ∨ revise(unit) ∧ repin, by what the
-    new gloss adds ∨ drops · anchor ∨ factors ⇒ revise(unit) ∧ repin · re-cut ⇔ s itself moved ;
-    measured : ~12 serial amendments re-cut one plan ~10× where the piece never moved⟩
+    new gloss adds ∨ drops · anchor ∨ factors ⇒ revise(unit) ∧ repin · re-cut ⇔ shard itself moved⟩
 suspect(unit) ⇒ the same response ↾ what moved beneath ⟨the concept that moved is a factor, ¬ the one
     unit spells ∴ its anchor moving alone ⇒ repin · a factor dropped beneath shows as the concept
     above it amended in factors⟩
 diverged(x) ⇒ reconcile(x) ⟨an ordinary write on x refuses⟩
 incoherent(P) ⇒ repaired by ordinary writes, one at a time
-reconcile ⊨ self ⟨reconciliation of plans ∧ units is the architect's alone⟩
-slices(P) cut on s ⟨¬ file-adjacency · files are a LAGGING proxy for modularity ∴
-    file-cut ⇒ ∀ unit ⊇ fragments of several c ⇒ executor finishes ∧ system incoherent⟩
+reconcile ⊨ planner ⟨reconciliation of plans ∧ units is the planner's alone⟩
+slices(P) cut on shards ⟨¬ file-adjacency · files are a LAGGING proxy for modularity ∴
+    file-cut ⇒ ∀ unit ⊇ fragments of several c ⇒ implementer finishes ∧ system incoherent⟩
 ⋃ slices(P) = P ∧ ∀ s₁, s₂ ∈ slices(P) : s₁ ≠ s₂ ⇒ s₁ ∩ s₂ = ∅
-∄ swap improving cross(slices(P)) ⟨argmin ↾ LOCAL · exhaustive ∧ deterministic ;
-    a global argmin over every assignment is ¬ decidable⟩
+∄ swap improving cross(slices(P)) ⟨LOCAL argmin · a global one is ¬ decidable⟩
 ∀ n < m : |wave(n)| = 1 ⇒ slices mis-cut ⟨a singleton non-terminal wave is a CHAIN⟩
 ∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ outputs(u) = ∅ ⟨the concurrency precondition⟩
 ∀ unit, u ∈ wave(n) : unit ≠ u ⇒ outputs(unit) ∩ refs(u) = ∅ ⟨disjoint outputs is NECESSARY
     ¬ sufficient : a deletion in unit dangles a reference in u⟩
 ⊨ disjoint-outputs ⇒ dispatch(wave(n)) needs-no-isolation
-∀ unit : effort(unit) ≤ capacity ⟨ready PROMISES an executor can FINISH · a unit past capacity
-    hands its successor a re-read, ¬ progress⟩
-effort(unit) > capacity ⇒ split on factors(denotes(realizes(unit))) ⟨each part realizes a factor ·
-    ¬ a file-cut⟩ ; factors = ∅ ⇒ SURFACE ⟨a primitive no executor finishes is ¬ primitive @ design⟩
-an executor exhausted mid-unit ⇒ effort(unit) mis-estimated ⇒ split ∨ SURFACE ≺ redispatch
-    ⟨¬ a chain of cold successors⟩
+∀ unit : effort(unit) ≤ capacity ⟨a unit past capacity, or an implementer exhausted mid-unit (effort mis-estimated), hands its successor a re-read, ¬ progress⟩
+effort(unit) > capacity ⇒ split on factors(denotes(realizes(unit))) ⟨each part realizes a factor⟩ ≺ redispatch
+    ; factors = ∅ ⇒ SURFACE ⟨a primitive no implementer finishes is ¬ primitive @ design⟩
 ∀ unit : footprint(unit) ⊆ outputs(unit) ⟨outputs IS the contention set ∴ an under-declared
     array silently voids every disjointness proof above⟩
 ∀ unit : occurs(realizes(unit)) ⊆ outputs(unit) ⟨a unit's footprint is its REFERENCE set, ¬ its
     definition site · resolve occurs BEFORE declaring outputs⟩
-    ⟨measured 6 under-declared arrays in one plan, ONE cause · declared 1 glob and
-     wrote 15 paths · 1 and 12 · 8 and 20⟩
 ∀ unit : ∃ r : ¬accept(unit)(r) ∧ ¬accept(unit)(pre(unit)) ⟨criteria that cannot FAIL, ∧ that
     already pass before the work, test nothing⟩
-census(P) ⊨ once ∧ pinned⟨commit⟩ ∧ cited by every unit ⟨¬ re-derived per executor⟩
+census(P) ⊨ once ∧ pinned⟨commit⟩ ∧ cited by every unit ⟨¬ re-derived per implementer⟩
 ∀ unit : measurement ∈ spec(unit) ⇒ measurement = claim⟨commit⟩ ∴ cite ⇔ ∄ change to its paths since
     that commit ; else re-derive ≺ cite ⟨a count in a unit is CENSUS OUTPUT, ¬ a datum · the tree
-    moves ∧ nothing reds · within P it moves only by landed outputs, each declared before dispatch⟩
+    moves ∧ nothing reds⟩
 ∀ unit : reach-leg(unit) ⊨ print(denominator) ⟨∄ denominator ⇒ found-nothing ≡ could-not-look⟩
 ∀ unit : conform(spec(unit))
-plan ≜ take(s) → census ⟨delegable⟩ → slice(s) → add(∀ unit) ⟨spec ∧ pin⟩ → ratify @ planner → advance`;
+plan ≜ the planner's procedure : take(shards) → census ⟨delegable⟩ → slice(shards) → add(∀ unit) ⟨spec ∧ pin⟩ → ratify @ planner → bind(P) ⟨only when ¬∃ bound P⟩ → advance(each ready unit) ↦ ${UNIT.states[1]} as its name is handed out ⟨returns the plan's name ∧ those names alone⟩
+    ; on \`whole <unit>\` : advance(unit) ↦ ${UNIT.satisfies}, hand out the newly ready ; ∀ unit completed ⇒ close(P)
+    ; on a stop ⟨an owed note blocking P⟩ : rectify ⟨repin ∨ revise ∨ retract ∨ add⟩ ∨ rebuild P ≺ the note is retracted ⟨the drift laws apply to a bound P⟩`;
 export const plan = {
     name: 'plan',
-    description: `use this skill to decompose ONE cut piece of a design into MECE units of work — each citing the single concept it realizes, with its inputs, dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a piece that cannot be planned as handed down is surfaced, never silently redrawn. Its verbs show a plan or a unit, add, advance, retract and revise units, revise, bind and close a plan, and reconcile either.`,
+    description: `use this skill to decompose the shards a design hands down into MECE units of work — each realizing exactly one shard and citing the single concept it realizes, with its dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a shard that cannot be planned as handed down is surfaced, never silently redrawn. It also carries the verbs that write a unit's ledger.`,
     formalBlock: FORMAL_BLOCK,
     runtime: { capability: 'plan', configuration: LIFECYCLE },
     composition: () => [design, note],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oCAAoC;AACpC,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,6BAA6B;AAC7B,EAAE;AACF,mFAAmF;AACnF,mFAAmF;AACnF,qFAAqF;AACrF,qFAAqF;AACrF,sEAAsE;AACtE,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,uFAAuF;AACvF,gFAAgF;AAEhF,MAAM,SAAS,GAAG;IAChB,IAAI,EAAE;QACJ,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC;QACvC,SAAS,EAAE,OAAO;QAClB,KAAK,EAAE,QAAQ;KAChB;IACD,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE;CACpE,CAAC;AACX,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC;AAE7C,MAAM,YAAY,GAChB;;;;;;;;;gBASc,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;mBACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;wBAEjB,IAAI,CAAC,SAAS;yBACb,IAAI,CAAC,KAAK;kCACD,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA+BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;uFAWxD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAgEqB,CAAC;AAE3H,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,krBAAkrB;IAC/rB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE;IACzD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;CAClC,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/plan/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oCAAoC;AACpC,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,6BAA6B;AAC7B,EAAE;AACF,mFAAmF;AACnF,mFAAmF;AACnF,qFAAqF;AACrF,qFAAqF;AACrF,sEAAsE;AACtE,EAAE;AACF,iFAAiF;AACjF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,iCAAiC;AAEjC,MAAM,SAAS,GAAG;IAChB,IAAI,EAAE;QACJ,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC;QACvC,SAAS,EAAE,OAAO;QAClB,KAAK,EAAE,QAAQ;KAChB;IACD,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE;CACpE,CAAC;AACX,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,SAAS,CAAC;AAE7C,MAAM,YAAY,GAAG;;;;;;;;gBAQL,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;mBACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;wBAEjB,IAAI,CAAC,SAAS;yBACb,IAAI,CAAC,KAAK;kCACD,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA+BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iMAqEkD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;8CACjK,IAAI,CAAC,SAAS;6JACoH,CAAC;AAEjL,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,uoBAAuoB;IACppB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE;IACzD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;IACjC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/probe/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 // COMPOSES NOTHING, and that is the repair.
 //
 // This cell used to declare `composition: () => [signify, elicit, conceptualize]` and import those
@@ -66,5 +67,6 @@ export const 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.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/probe/skill.ts"],"names":[],"mappings":"AAEA,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;CACtB,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,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"}

package/dist/skills/signify/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 // COMPOSES NOTHING, and that is the repair.
 //
 // This cell used to declare `composition: () => [exemplify, conceptualize, materialize]` and import those
@@ -67,5 +68,6 @@ minimal(a) ⇔ ∄ c carried by a : a re-states fired(α(c))
 conform(a)  ⇔  register(a) = σ*
 verbatim(a) ⇒ register(a) = σ*`,
     composition: () => [],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/signify/skill.ts"],"names":[],"mappings":"AAEA,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,mNAAmN;IAChO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,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,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mNAAmN;IAChO,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAiDmC;IAChD,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.8.0",
+  "version": "0.10.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.",
   "license": "MIT",
   "engines": {
@@ -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.5.0"
+    "@cratylus/schema": "0.6.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.10.0",
-    "@cratylus/runtime": "0.5.0",
+    "@cratylus/forge": "0.11.1",
+    "@cratylus/runtime": "0.7.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",

package/dist/genus/founding-doctrine.d.ts

@@ -1,7 +0,0 @@
-/**
- * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
- * above every agent Target's `## Archetype` and every SKILL.md's first section.
- * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause, and
- * nothing whose truth is contingent on this workspace.
- */
-export declare const foundingDoctrine: string;

package/dist/genus/founding-doctrine.js

@@ -1,13 +0,0 @@
-import { cratylism } from '../dimensions/engineering-principles/cratylism.js';
-/**
- * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
- * above every agent Target's `## Archetype` and every SKILL.md's first section.
- * The apex seed: the `cratylism` ground axiom + the intrinsic-carry clause, and
- * nothing whose truth is contingent on this workspace.
- */
-export const foundingDoctrine = `## Prime Principle
-
-${cratylism}
-
-intrinsic ⟨¬ ambient⟩`;
-//# sourceMappingURL=founding-doctrine.js.map

package/dist/genus/founding-doctrine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"founding-doctrine.js","sourceRoot":"","sources":["../../src/genus/founding-doctrine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;EAE9B,SAAS;;sBAEW,CAAC"}