@cratylus/canon 0.7.0 → 0.9.0

package/dist/skills/deliver/skill.js

@@ -1,160 +1,89 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 import { design } from '../design/skill.js';
 import { note } from '../note/skill.js';
 import { plan } from '../plan/skill.js';
-// WHERE THE TRUST DEFECT IS CLOSED. Acceptance keyed to a unit's own criteria is a
-// closed loop: the author writes the unit, writes its criteria, and checks the return
-// against them. Every term comes from one source, so an executor satisfying the letter
-// passes while the design goes unmet. Instructing the principal to "actually verify"
-// cannot repair this — verification is a TWO-DESCRIPTION operation, and with one
-// description there is no operation to perform, so it degenerates into re-reading the
-// claim. The second description is the design, which is why this cell composes it.
+// WHY THE WHOLE CHECK RUNS HERE, ONCE. A unit proven alone has proven nothing about the
+// combination: a branch's green says nothing about the line after other landings, and an
+// implementer or assayer re-running the project's check on nearly the same tree proves
+// nothing new and spends the architect's wait for it. So the check is the integrator's, run
+// once per combination on the combined tree. It is reached only after the verdict, which is
+// what keeps the line to approved work: the assayer is the one judge of a unit and
+// acceptance rests on its verdict, never on the implementer's return, never on a merge and
+// never on a green check. Judging is a two-description act held by a party that holds the
+// design and not the spec; a party that carries the verdict onward reaches none of its own.
 //
-// The split that matters: the EXECUTOR verifies ⟨did I build it per the spec⟩ and the
-// PRINCIPAL validates ⟨is this what the design called for⟩. Both are legitimate and
-// neither substitutes. Today only the first exists in most loops.
+// A RED IS A REPORT, NEVER A PATCH. Repairing on the line would hand the architect an
+// approved-looking whole nobody judged, and would make the integrator the builder its own
+// check is meant to be independent of. The report is an address (the unit and the failing
+// check) so the architect can send it to the implementer that built the unit without
+// reading behind it; the return of a unit, of a verdict and of a report is a name and a
+// commit, never an account.
 //
-// The three validation questions are cheap BY CONSTRUCTION, and that is load-bearing
-// rather than convenient: a check costing more than redoing the work is skipped, and
-// no instruction survives that gradient. Naming discipline is what buys the cheapness —
-// if the artifact spells its concept, two of the three are reading a name.
+// THE LINE IS NOT MAIN. Approved work accumulates on the plan's own integration line, cut
+// from main when the plan is bound, and the finished whole reaches main by the operator's
+// sign-off, which the integrator asks for and never takes: a push is a release decision
+// and a release decision is not the integrator's to make.
 //
-// WHERE THE READ GOES, AND WHY THE VERDICT DOES NOT FOLLOW IT. `validate ⊨ artifact` is
-// right and it has a cost: reading artifacts is reading files — paths, identifiers, call
-// sites — which is exactly the mechanical work the architect's contract calls a descent.
-// Left there, the skill obliges the design-holder to descend on every wave, and by the
-// third wave the design-holder is a code reviewer holding a lattice it can no longer
-// carry. So `validate` is two operations under one name and they separate cleanly: the
-// ASSAY (read the landed artifact, re-derive which concepts it realizes) is mechanical,
-// substrate-bound and DELEGABLE; the JUDGMENT (what an unachieved concept means —
-// rejection, an `amend(C)` because execution established a yield, or a design that was
-// wrong) is keyed to C and is NOT.
-//
-// A THIRD PARTY DOES NOT REOPEN THE DEFECT THIS CELL CLOSES. The law forbids accepting
-// on a claim from the party that BUILT the thing: one description, a closed loop. There
-// are still two descriptions here and they are still held by different parties — the
-// executor holds the spec and not the design, the assayer holds the design and not the
-// spec. The artifact read the law demands still happens; it happens at the one site in
-// the loop where reading substrate is the work rather than a descent, and what reaches
-// the principal is in the only vocabulary the principal can check without descending.
-const FORMAL_BLOCK = `C      @ design
-c      @ design
+// WHO OWNS WHAT, so the loop reads in order: routing by name is the architect's; binding
+// the plan and recording a unit active, completed and the plan closed is the planner's;
+// building and verifying against the spec is the implementer's; the verdict is the
+// assayer's; combining, the whole check, the records commit and the ask to release are the
+// integrator's. A finding is captured as a note by the party that met it and is never
+// chased; when a finding enters the design is the design skill's law.
+const FORMAL_BLOCK = `shard  @ design
 anchor @ design
-gloss  @ design
-factors @ design
-denotes @ design
-amend  @ design
-yield  ≜ what execution established ∧ ¬ derivable from C
+yield  ≜ what execution established ∧ ¬ derivable from the design
 P      @ plan
 unit   @ plan
-wave   @ plan
-frontier @ plan
-realizes @ plan
-advance, bind, close, bound, ready, capacity @ plan
-show ⟨C⟩ @ design
-show ⟨P ∧ unit⟩ @ plan
+advance, bind, close, closed, bound @ plan
 accept @ plan ⟨the MECHANICAL half⟩
 outputs @ plan
-artifact : P → ℘(path) ⟨what landed · the EVIDENCE⟩
-r      ≜ an executor's return
+artifact : P → ℘(path) ⟨what landed⟩
+r      ≜ a return ⟨an ADDRESS : a name ∧ a commit · ¬ an account⟩
 conform @ signify
-executor : P ⇀ agent
-self   @ design
 capture @ note
-spells : path × anchor → 𝔹 ⟨identifiers · path · public surface bear the sign⟩
-covers : path × ℘(C) → 𝔹 ⟨observable behaviour ≅ the factorization · nothing missing
-         ∧ nothing extra⟩
-sole   : path × anchor → 𝔹 ⟨∄ other artifact realizing the same concept⟩
-verify : P × return → 𝔹 ⟨the EXECUTOR's · built-it-right, against spec · ↾ accept(unit), ¬ gate⟩
-gate   ≜ the project's whole check ⟨every suite · typecheck · build : what a green main demands⟩
-integrate(unit) ≜ merge artifact(unit) into main ⟨pre gate green on the MERGED tree · a branch's
-    green says nothing about main after other landings⟩
-integrator : P ⇀ agent ⟨one per P · runs gate ∧ integrate ∧ carries the state moves self decided, ¬ decides them⟩
-validate : P → 𝔹 ⟨the PRINCIPAL's · built-the-right-thing, against C⟩
-assay  : artifact → ℘(C) ⟨which concepts the artifact ACTUALLY realizes · the REVERSE of plan⟩
-assayer : unit ⇀ agent ⟨role = assayer · holds C ∧ ¬ holds spec(unit)⟩
-achieved : unit → 𝔹 ⟨the three questions, answered against the assay⟩
-unachieved : unit → ℘(⟨c, uncovered-factor, locus⟩) ⟨what crosses UPWARD⟩
+architect  : agent ⟨role = architect · holds the design · sends each name to the agent that acts on it⟩
+planner    @ plan
+implementer : P ⇀ agent ⟨role = implementer · builds and commits its own unit⟩
+assayer : unit ⇀ agent ⟨role = assayer · the ONE judge of a unit⟩
+integrator : P ⇀ agent ⟨role = integrator · one per P · combines · runs gate · commits records · asks release⟩
+operator ≜ the human who signs off a release
+achieved : unit → 𝔹 ⟨the assayer's verdict⟩
+line(P) ≜ the integration line of P, branch \`plan/<plan>\` cut from main when P is bound ⟨¬ main⟩
+gate   ≜ the project's whole check ⟨every suite · typecheck · build : what a green line demands⟩
+verify : P × return → 𝔹 ⟨the IMPLEMENTER's · built-it-right, against spec⟩
+integrate(unit) ≜ merge artifact(unit) onto line(P) ⟨pre achieved(unit)⟩
+whole(unit) ≜ line(P) with unit integrated ∧ gate green
 defect ≜ ⟨symptom, locus, provenance⟩
-finding ≜ a yield ∨ an operator steer bearing on C ∧ ¬ yet in C
 impedes : defect × P → 𝔹
-fold   ≜ one amend(C) taking every finding in hand
 cost   : act → effort
-file(d) ≜ capture(d) ⟨its topic names the unit as \`u of plan p\` · beside the path ∴ it blocks nothing⟩
+file(d) ≜ capture(d) ⟨filed by the party that met d · its topic names the unit as \`u of plan p\` · beside the path ∴ it blocks nothing⟩
 electable ≜ { P | ¬terminal(P) ∧ ¬occupied(P) }
 terminal : P → 𝔹
+release(P) ≜ line(P) reaches main ⟨the operator's sign-off · a pull request where the repository has a forge remote and \`gh\`, otherwise the exact git command⟩
 
 ∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
-achieved(unit) ⇔ realizes(unit) ∈ assay(artifact(unit))
-    ∧ spells(artifact(unit), realizes(unit))
-    ∧ covers(artifact(unit), factors(denotes(realizes(unit))))
-    ∧ sole(artifact(unit), realizes(unit))
-unachieved(unit) = ∅ ⇔ achieved(unit)
-unachieved ⊨ C-typed ⟨it crosses in C's OWN vocabulary · mechanism-prose ⟨naming · structure ·
-    test-quality⟩ ⇒ REFUSE ∵ it descends the principal it was dispatched to spare⟩
-locus ⊨ ROUTED ∧ ¬ read ⟨an ADDRESS so the redispatch has one · a citation is substrate, and
-    handing the principal substrate is the same defect in smaller pieces⟩
-assay ⊨ artifact ⟨the ASSAYER reads the files · the ONE site in the loop where
-    substrate-reading is ¬ a descent⟩
-assayer ⊥ executor ⟨TWO descriptions, two witnesses : executor holds spec ∧ ¬ holds C ·
-    assayer holds C ∧ ¬ holds spec⟩
-validate(unit) ≜ unachieved(unit) = ∅ ⟨the principal JUDGES the assay ∧ ¬ re-reads the
-    artifact · the READ is delegable · the VERDICT is ¬ delegable ∵ keyed to C, which the
-    principal alone amends⟩
-validate ⊨ artifact ⟨NEVER r · a summary is a CLAIM ∧ the file is EVIDENCE ·
-    an acceptance that read only the return has accepted nothing⟩
-validate ⊨ self ⟨¬ delegable · the executor cannot judge its own conformance ∵ it
-    holds the spec ∧ ¬ the design⟩
-verify ⊥ validate ⟨two checks, two witnesses · neither substitutes ; an executor's
-    green suite proves the EXECUTOR's own assertion ∧ nothing about the design⟩
-judge(unit) ≜ verify(unit, r) ∧ validate(unit) ⇒ advance(unit) ⟨the acceptance⟩ ; ¬ ⇒ r rejected
-    back to executor(unit) ∧ ¬advance(unit)
-    ⟨r lands VERBATIM ≺ any verdict on it · the loss mode is read-reason-discard,
-     and it takes everything when a run dies mid-judgement⟩
-    ⟨fan-in is as order-sensitive as fan-out : ∀ unit dispatched, confirm executor(unit)
-     RETURNED · outputs(unit) exist ≠ executor(unit) returned⟩
-¬validate(unit) ⇒ redispatch(executor(unit), unachieved(unit)) ⟨the flaw handed down is
-    CONCEPTUAL ∧ ¬ a review · executor(unit) is the SAME agent that built it while it has
-    capacity ; a cold successor re-reads what it built⟩
-gate ⊨ integrate ∧ ¬ verify ⟨the whole check runs ONCE per landing, by the integrator · an
-    executor ∨ assayer re-running it proves nothing new on nearly the same tree⟩
-integrate ⊥ judge ⟨a merge is DURABILITY ∧ ¬ acceptance · acceptance is advance(unit) after the
-    assay⟩ ∴ integrate ≺ assay admitted ∧ the next ready unit dispatches while the assay runs
-    ⟨ready waits on satisfied deps ∴ ¬ a dependent builds on an unaccepted unit · the assay reads
-     artifact(unit) at its landing commit ∵ main moves under a pipelined assay⟩
-integrator ⊨ ¬ validate ⟨it carries a verdict ∧ ¬ reaches one⟩
-cost(validate) < cost(rebuild) ⟨else the gradient points at skipping · the cheapness
-    is BOUGHT by conform(anchor) ∴ naming discipline is the verification budget⟩
-¬spells ⇒ REFUSE ≺ any behavioural read ⟨the traceability arrow breaks at the cheapest
-    place it will ever be visible⟩
-¬covers ∧ extra ⇒ a second concept smuggled in unnamed ⇒ amend(C) ∨ REFUSE
-¬sole ⇒ duplication ⟨the observable signature of a vision that fragmented⟩
-dispatch(P) ≜ ∀ unit ∈ frontier(P) ⟨ready(unit)⟩ concurrently ⟨advance(unit) ∧
-    executor(unit) runs spec(unit)⟩ ; pre bound(P) ∧ ⊨ disjoint-outputs
-∀ c : ∄ unit ⟨realizes(unit) = anchor(c)⟩ ⇒ SURFACE ⟨a concept nothing builds is design agreed ∧
-    unbuilt · the reverse orphan is plan's⟩
+accepted(unit) ⇔ achieved(unit) ⟨acceptance rests on the assayer's verdict · never on r, never on a merge, never on a green gate⟩
+integrator ⊨ ¬ judges ⟨it carries a verdict onward ∧ reaches none · the verdict arrived before it was reached⟩
+integrator ⊨ takes(unit) ⇔ accepted(unit) ⟨what the architect sends it is a unit's name ∧ commit after an achieved verdict⟩
+integrate(unit) ⇒ gate ONCE on the combined tree ⟨a branch's green says nothing about the line after other landings · an implementer ∨ assayer re-running gate proves nothing new on nearly the same tree⟩
+integrate(unit) ∧ gate green ⇒ commit ⟨the records written since : plan ∧ design ∧ note · by pathspec⟩ ∧ report \`whole <unit> of <plan>\` ⟨whole(unit) · the architect sends it to the planner, which records advance(unit) completed ∧ hands out the newly ready names⟩
+integrate(unit) ∧ ¬ gate green ∨ a merge conflict ⇒ line(P) UNCHANGED ∧ report \`red <unit> of <plan>: <failing check>\` ⟨the architect sends it to the implementer that built the unit · the integrator repairs nothing⟩
 impedes(d, unit) ⇔ d standing ⇒ ∄ r : accept(unit)(r)
-finding ⇒ fold ≺ self's next dispatch ∨ judge ∨ close ⟨findings BATCH between two of self's acts ∧
-    never outlive one⟩
-    ⟨held past a judge, a unit is accepted against a concept known false · held past close(P), the
-     drift it causes lands on units never asked again · a hold keyed to a LATER act is a lock only
-     that act checks ∴ a branch merge ∨ a concurrent session walks past it⟩
-fold ⊨ drifted(unit) answered ↾ what moved @ plan ⟨the measured cost was the RESPONSE to amending,
-    ¬ amending : ~12 serial amendments re-cut one plan ~10× where the piece never moved⟩
-impedes(d, unit) ⇒ fix(d) ⟨a regression in the path is repaired, ¬ surfaced⟩
+finding ∨ d ⊨ capture ⟨a note by the party that met it : implementer ∨ assayer ∨ integrator ∨ architect · the operator's steer by the architect · it reaches the architect as a note, ¬ a return⟩ ; when a finding enters the design is the law of yield ≠ ∅ @ design
+impedes(d, unit) ⇒ an implementer repairs it ⟨a regression in the path goes back to the unit's implementer by way of the architect · the integrator makes no fix⟩
 ¬impedes(d, unit) ⇒ file(d) ∧ ¬fix(d) ⟨a defect BESIDE the path is filed, ¬ chased⟩
 cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearing law⟩
-∃ P : ¬terminal(P) ⇒ ∃ P : bound(P) ⟨WIP = 1, held by bind : it returns the plan bound before ·
-    finish before starting⟩
+∃ P : ¬terminal(P) ⇒ ∃ P : bound(P) ⟨WIP = 1, held by bind : the planner binds it · finish before starting⟩
 elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
-terminal(P) ⇒ close(P) ⟨obligation ¬ permission · an unclosed terminal plan is WIP
-    that is not work · a closed plan stays readable⟩ ; C persists ⟨plans come ∧ go ABOVE the design⟩
-deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → integrate ⟨integrator, on gate⟩ →
-    assay ⟨assayer, on artifact⟩ → validate ⟨self, on the assay⟩ → judge → fold ⇔ finding →
-    advance → close`;
+terminal(P) ⇒ close(P) ⟨obligation ¬ permission : the planner closes it · an unclosed terminal plan is WIP that is not work · a closed plan stays readable⟩
+closed(P) ⇒ ask the operator release(P) ⟨the integrator asks · it never moves main⟩
+deliver ≜ bind ⟨planner⟩ → send ⟨architect, by name⟩ → verify ⟨implementer⟩ → achieved ⟨assayer⟩ → integrate ∧ gate ⟨integrator, once on the combined tree⟩ → whole ⟨planner records completed⟩ → close ⟨planner⟩ → release ⟨operator, asked by the integrator⟩`;
 export const deliver = {
     name: 'deliver',
-    description: `use this skill to execute a plan and ACCEPT its results — dispatch a wave of units to executors, integrate each landing into main once the project's whole check is green, and validate each landed artifact against the design rather than against the executor's report; a merge is durability and acceptance comes after the assay. Reach for it whenever delegated work comes back. Validation is three cheap questions — does the artifact spell its concept's name, does its behaviour cover that concept's factorization exactly, and does anything else already realize it — read off the files themselves, never off a summary. It also carries the conduct of the work: one plan bound at a time, finish before starting, repair what blocks the path and merely file what sits beside it, send a gap back to the agent that built it, and fold what execution or the operator teaches about the design into it before the next dispatch, judgement or close, several findings in one amendment when they arrive together.`,
+    description: `use this skill to make a plan's approved work whole and see it released — take each unit whose assay verdict is achieved, integrate it onto the plan's integration line, run the project's whole check once on the combined tree, and on green commit the records written since by pathspec and report the unit whole, or on red or a merge conflict leave the line as it was and report the unit and the failing check. Reach for it whenever an achieved unit arrives by name and commit, and when the plan closes. It reads the loop in order: the architect sends each name, the planner binds the plan and records units active and completed and the plan closed, the implementer builds, and the assayer's verdict, the one judgement of a unit, is the acceptance rather than the implementer's return; a merge is durability, and neither a merge nor a green check accepts. When the plan closes it asks the operator to release the line to main and never moves main itself. It also carries the conduct of the work: one plan bound at a time, finish before starting, a defect that impedes the path goes back to its implementer by way of the architect and one beside it is only filed, and a finding is captured as a note by the party that met it, entering the design when the design skill's law says.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [design, plan, note],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,qFAAqF;AACrF,iFAAiF;AACjF,sFAAsF;AACtF,mFAAmF;AACnF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,kEAAkE;AAClE,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,wFAAwF;AACxF,2EAA2E;AAC3E,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,yFAAyF;AACzF,uFAAuF;AACvF,qFAAqF;AACrF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,uFAAuF;AACvF,mCAAmC;AACnC,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,qFAAqF;AACrF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,sFAAsF;AAEtF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkHkB,CAAC;AAExC,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,s+BAAs+B;IACn/B,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;CACxC,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/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;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wFAAwF;AACxF,yFAAyF;AACzF,uFAAuF;AACvF,4FAA4F;AAC5F,4FAA4F;AAC5F,mFAAmF;AACnF,2FAA2F;AAC3F,0FAA0F;AAC1F,4FAA4F;AAC5F,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,4BAA4B;AAC5B,EAAE;AACF,0FAA0F;AAC1F,0FAA0F;AAC1F,wFAAwF;AACxF,0DAA0D;AAC1D,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,mFAAmF;AACnF,2FAA2F;AAC3F,sFAAsF;AACtF,sEAAsE;AAEtE,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gQAgD8P,CAAC;AAEpR,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,8vCAA8vC;IAC3wC,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

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,13 +75,13 @@ 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>\`
@@ -91,10 +92,9 @@ 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⟩
 
 ∀ 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
+∀ 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⟩
@@ -112,50 +112,48 @@ 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
+∀ unit : effort(unit) ≤ capacity ⟨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⟩
+    ; factors = ∅ ⇒ SURFACE ⟨a primitive no implementer finishes is ¬ primitive @ design⟩
+an implementer exhausted mid-unit ⇒ effort(unit) mis-estimated ⇒ split ∨ SURFACE ≺ redispatch
     ⟨¬ a chain of cold successors⟩
 ∀ 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 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 shard 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.`,
     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;;;;;;;;;;;uFAWxD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iMA0D4F,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,utBAAutB;IACpuB,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