@cratylus/canon 0.8.0 → 0.10.0

package/dist/roles/assayer.js

@@ -25,16 +25,20 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 // EVERY ASPECT BELOW IS CHOSEN AGAINST THE ONE FAILURE MODE — turning into a code
 // reviewer. `thoroughness` rewards answering every concept in `realizes(unit)` rather
 // than finding something to say. `satisfice` stops at the answer instead of reading on.
-// `structured-data` makes the report a list of ⟨concept, uncovered-factor, locus⟩ rather
-// than a narrative, and a narrative is where mechanism-prose gets in. `cratylism`
-// carries the cheapest of the three questions — does the artifact SPELL its concept —
-// and `first-principles` forbids inheriting the executor's own account of what it built.
+// `structured-data` makes the verdict a unit's name, its implementer and a list of
+// ⟨concept, uncovered-factor, locus⟩ rather than a narrative, and a narrative is where
+// mechanism-prose gets in. `cratylism` carries the cheapest of the three questions —
+// does the artifact SPELL its concept — and `first-principles` forbids inheriting the
+// implementer's own account of what it built.
 //
-// `design` and no `deliver`: it must read the lattice to lift into it, and judging is
-// not its remit.
+// `design` and `note`, no `deliver`: it must read the shard and its closure to judge
+// against them, and it captures a finding beside the unit as a note; the judgement it
+// emits is its own, so it needs no skill about who accepts. Its one plan write, `cratylus
+// plan assay …` recording the verdict on the commit it judged, is stated in the role sign
+// rather than by `plan`, which prints a unit's spec.
 export const assayerRole = {
     sign: assayer_role,
-    skills: ['design'],
+    skills: ['design', 'note'],
     vector: {
         formality: plain_formality,
         audienceAdaptation: maintenance_audienceAdaptation,

package/dist/roles/assayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/roles/assayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,YAAY,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,cAAc,IAAI,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAC/G,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,uBAAuB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AAC/I,OAAO,EAAE,aAAa,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACvH,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAGnI,uFAAuF;AACvF,uFAAuF;AACvF,0BAA0B;AAC1B,EAAE;AACF,kFAAkF;AAClF,sFAAsF;AACtF,wFAAwF;AACxF,yFAAyF;AACzF,kFAAkF;AAClF,sFAAsF;AACtF,yFAAyF;AACzF,EAAE;AACF,sFAAsF;AACtF,iBAAiB;AAEjB,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,oFAAoF;QACpF,mEAAmE;QACnE,YAAY,EAAE,kCAAkC;QAChD,iEAAiE;QACjE,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,kBAAkB;QAC3B,iBAAiB,EAAE,uBAAuB;QAC1C,WAAW,EAAE,qBAAqB;QAClC,YAAY,EAAE,2BAA2B;QACzC,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/roles/assayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,YAAY,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,cAAc,IAAI,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAC/G,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,uBAAuB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AAC/I,OAAO,EAAE,aAAa,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACvH,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAGnI,uFAAuF;AACvF,uFAAuF;AACvF,0BAA0B;AAC1B,EAAE;AACF,kFAAkF;AAClF,sFAAsF;AACtF,wFAAwF;AACxF,mFAAmF;AACnF,uFAAuF;AACvF,qFAAqF;AACrF,sFAAsF;AACtF,8CAA8C;AAC9C,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qDAAqD;AAErD,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,oFAAoF;QACpF,mEAAmE;QACnE,YAAY,EAAE,kCAAkC;QAChD,iEAAiE;QACjE,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,kBAAkB;QAC3B,iBAAiB,EAAE,uBAAuB;QAC1C,WAAW,EAAE,qBAAqB;QAClC,YAAY,EAAE,2BAA2B;QACzC,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}

package/dist/roles/hold.js

@@ -22,7 +22,7 @@
 // precedence rule, no ordering question.
 //
 // SINGULAR ARITY IS THE POINT, not a simplification. A role is the CONTRACT A PEER
-// DISPATCHES AGAINST: when an architect hands a cut piece to a planner it reasons about
+// DISPATCHES AGAINST: when an architect hands a shard to a planner it reasons about
 // the planner's role to know what comes back. A union of roles is a contract no
 // dispatcher can reason about, and it would readmit role conflict — incompatible
 // demands between two positions held at once — which singular arity deletes outright.

package/dist/roles/hold.js.map

@@ -1 +1 @@
-{"version":3,"file":"hold.js","sourceRoot":"","sources":["../../src/roles/hold.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hold.js","sourceRoot":"","sources":["../../src/roles/hold.ts"],"names":[],"mappings":"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"}

package/dist/roles/implementer.js

@@ -1,6 +1,5 @@
 import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
 import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
-import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
 import { missionCommand } from '../dimensions/autonomy/mission-command.js';
 import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
 import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
@@ -23,16 +22,28 @@ import { limitationDisclosure as limitationDisclosure_transparency } from '../di
 // workflow skill by design: a skill guides an agent through decisions it must make, and
 // this position's decisions were made for it. It needs a unit of work, tools, and the
 // discipline to stay inside the boundary.
+//
+// `note` and nothing else, because what it could not prove and any finding beside the
+// path leave it as a note, and `note` composes nothing, so the implementer still never
+// receives `design`. Its one plan read, `cratylus plan show <unit> --plan <plan>`, and its
+// one plan write, `cratylus plan land …` recording each commit that holds the unit, are
+// stated in the role sign rather than by `plan`, which composes `design`.
 export const implementerRole = {
     sign: implementer_role,
+    skills: ['note'],
     vector: {
         formality: plain_formality,
         audienceAdaptation: maintenance_audienceAdaptation,
-        // `limitation-disclosure`: this position's entire value to the layer above is an
-        // honest account of what it could NOT establish. A clean report that hides an
-        // unproven leg is worse than a failure, because it is acted on.
+        // `limitation-disclosure`, and its channel is a NOTE. What this position could not
+        // establish is owed to the design, and the design takes a delegate's finding as a
+        // note; the return is a name with no account, and the unit is judged on the
+        // assayer's verdict, never on anything said about the work. An unproven leg left
+        // out of every note is the hazard: the unit is accepted on a reader's verdict
+        // without anyone having been told the leg was open.
         transparency: limitationDisclosure_transparency,
-        autonomy: [missionCommand, handoff_autonomy],
+        // `mission-command` alone. `handoff` shapes a report that leads with its evidence and
+        // ends on the operator's action items, and this position hands up a name, not a report.
+        autonomy: [missionCommand],
         objective: correctness_objective,
         engineeringPrinciples: [
             cratylism_engineeringPrinciples,

package/dist/roles/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,0CAA0C;AAE1C,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,iFAAiF;QACjF,8EAA8E;QAC9E,gEAAgE;QAChE,YAAY,EAAE,iCAAiC;QAC/C,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,6BAA6B;QACjD,OAAO,EAAE,2BAA2B;QACpC,iBAAiB,EAAE,uBAAuB;QAC1C,0EAA0E;QAC1E,6EAA6E;QAC7E,6CAA6C;QAC7C,WAAW,EAAE,qBAAqB;QAClC,mFAAmF;QACnF,8EAA8E;QAC9E,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,0CAA0C;AAC1C,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,2FAA2F;AAC3F,wFAAwF;AACxF,0EAA0E;AAE1E,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,kFAAkF;QAClF,4EAA4E;QAC5E,iFAAiF;QACjF,8EAA8E;QAC9E,oDAAoD;QACpD,YAAY,EAAE,iCAAiC;QAC/C,sFAAsF;QACtF,wFAAwF;QACxF,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,QAAQ,EAAE,gCAAgC;QAC1C,kBAAkB,EAAE,6BAA6B;QACjD,OAAO,EAAE,2BAA2B;QACpC,iBAAiB,EAAE,uBAAuB;QAC1C,0EAA0E;QAC1E,6EAA6E;QAC7E,6CAA6C;QAC7C,WAAW,EAAE,qBAAqB;QAClC,mFAAmF;QACnF,8EAA8E;QAC9E,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/roles/integrator.d.ts

@@ -0,0 +1,2 @@
+import type { RoleCell } from './hold.js';
+export declare const integratorRole: RoleCell;

package/dist/roles/integrator.js

@@ -0,0 +1,51 @@
+import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { operationsDelivery as operationsDelivery_capabilities } from '../dimensions/capabilities/operations-delivery.js';
+import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { delivery as delivery_objective } from '../dimensions/objective/delivery.js';
+import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
+import { integrator as integrator_role } from '../dimensions/role/integrator.js';
+import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
+import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
+// THE RUNG THAT MAKES APPROVED WORK WHOLE. It carries no `software-engineering`, and
+// the absence is the same decision as `writes ≠ artifact` in its contract: this position
+// combines and checks, and a holder whose capabilities included building would be one
+// good intention away from repairing a red on the line.
+//
+// `deliver`, and it is the plan-side conduct of the loop, the skill that says what
+// arrives here, in what order, and what goes back. Skill routing gives it with `design`,
+// `plan` and `note`, so the position reads the records it commits without being handed
+// them.
+export const integratorRole = {
+    sign: integrator_role,
+    skills: ['deliver'],
+    vector: {
+        // `mission-command` and no `principal-self`: it is dispatched with a unit and a
+        // commit, acts inside that intent, and answers with a fact. The one decision that
+        // is not its own, releasing to main, it asks the operator for.
+        autonomy: [missionCommand],
+        // `delivery`: what this position produces is the integrated green whole, and a
+        // combination it could not check is a delivery that did not happen. The phrase
+        // carries the whole objective, so it is cited whole rather than paraphrased.
+        objective: delivery_objective,
+        guardrails: [honesty_guardrails],
+        // `verification-testing` is the check itself; `operations-delivery` is the line and
+        // the release it asks for. `software-engineering` is deliberately absent: see above.
+        capabilities: [
+            verificationTesting_capabilities,
+            operationsDelivery_capabilities,
+        ],
+        // `file-ops`, for the git acts the contract reserves (combine, commit by pathspec):
+        // its `vcs` factor is what tells a holder a commit is durability and not acceptance.
+        actions: [fileOps_actions],
+        reasoningStrategy: react_reasoningStrategy,
+        // `satisfice`: one check per combination is the whole remit. Running it again, or
+        // widening it, is a second concept and would spend the architect's wait for nothing.
+        satisficing: satisfice_satisficing,
+        // The oracle is the project's own check, executed: it runs it, and a green it did
+        // not observe is not one it reports.
+        selfEvaluation: executableTestOracle_selfEvaluation,
+    },
+};
+//# sourceMappingURL=integrator.js.map

package/dist/roles/integrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/roles/integrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AAC1H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAGtI,qFAAqF;AACrF,yFAAyF;AACzF,sFAAsF;AACtF,wDAAwD;AACxD,EAAE;AACF,mFAAmF;AACnF,yFAAyF;AACzF,uFAAuF;AACvF,QAAQ;AAER,MAAM,CAAC,MAAM,cAAc,GAAa;IACtC,IAAI,EAAE,eAAe;IACrB,MAAM,EAAE,CAAC,SAAS,CAAC;IACnB,MAAM,EAAE;QACN,gFAAgF;QAChF,kFAAkF;QAClF,+DAA+D;QAC/D,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,+EAA+E;QAC/E,+EAA+E;QAC/E,6EAA6E;QAC7E,SAAS,EAAE,kBAAkB;QAC7B,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,oFAAoF;QACpF,qFAAqF;QACrF,YAAY,EAAE;YACZ,gCAAgC;YAChC,+BAA+B;SAChC;QACD,oFAAoF;QACpF,qFAAqF;QACrF,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,iBAAiB,EAAE,uBAAuB;QAC1C,kFAAkF;QAClF,qFAAqF;QACrF,WAAW,EAAE,qBAAqB;QAClC,kFAAkF;QAClF,qCAAqC;QACrC,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/roles/planner.js

@@ -22,17 +22,18 @@ import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } fro
 import { comprehension as comprehension_situationAwareness } from '../dimensions/situation-awareness/comprehension.js';
 import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
 // THE MIDDLE RUNG. Holds `mission-command` and `handoff` but NOT `principal-self`: the
-// boundary was drawn above it, and the contract's `⊄ writes C` is what makes that
+// shards were cut above it, and the contract's `⊄ writes C` is what makes that
 // refusal structural rather than a matter of discipline.
 //
 // `system-design` is absent alongside `software-engineering` — this position neither
-// designs nor builds. What it owns is the census and the cut-into-units.
+// designs nor builds. What it owns is the plan: the census, the units cut from the
+// shards it is handed, and the plan's records from binding to closing.
 export const plannerRole = {
     sign: planner_role,
     // The role declares one skill, `plan`, and is given plan's composition with it
-    // (`design`, `note`), so it reads the boundary it plans inside. `deliver` belongs
-    // to the rung ABOVE, which draws that boundary; the rung BELOW declares none at
-    // all, because an implementer's decisions are made for it by its spec.
+    // (`design`, `note`), so it reads the shards it plans. `deliver` belongs to the rung
+    // ABOVE, which cuts them; the rung BELOW declares none at all, because an
+    // implementer's decisions are made for it by its spec.
     skills: ['plan'],
     vector: {
         formality: plain_formality,

package/dist/roles/planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"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"}

package/dist/skills/create-skill/skill.js

@@ -1,3 +1,4 @@
+import { primePrinciple } from '../../genus/prime-principle.js';
 import { formalize } from '../formalize/skill.js';
 export const createSkill = {
     name: 'create-skill',
@@ -23,5 +24,6 @@ never \`X ≜ <cell>\` in prose ; sibling deps boundary-bound via Bindings
 create-skill ≜ name-as-verb → write fm → H1 + formula ( + Bindings ⇔ composes-siblings ) → author block @ formalize → resolve → verify → iterate-until-green → deploy
 boundary ≜ the skill cell ; prose→set-builder @ formalize ; dimension-vectors @ create-agent ; mints no dimension values`,
     composition: () => [formalize],
+    preamble: primePrinciple,
 };
 //# sourceMappingURL=skill.js.map

package/dist/skills/create-skill/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/create-skill/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,cAAc;IACpB,WAAW,EAAE,0YAA0Y;IACvZ,WAAW,EACT;;;;;;;;;;;;;;;;;;;yHAmBwI;IAC1I,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/create-skill/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,CAAC,MAAM,WAAW,GAAU;IAChC,IAAI,EAAE,cAAc;IACpB,WAAW,EAAE,0YAA0Y;IACvZ,WAAW,EACT;;;;;;;;;;;;;;;;;;;yHAmBwI;IAC1I,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;IAC9B,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/deliver/skill.js

@@ -1,160 +1,118 @@
+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, AND IT HOLDS THE PLAN'S WHOLE WORK. Approved work accumulates on
+// the plan's own integration line, cut at the integrator's first dispatch from the commit
+// the plan's units are built on (the HEAD of the checkout where the plan was bound) and
+// never from bare main: a line cut from main lacks the history the units stand on, and
+// that history then conflicts at combination. 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.
+// RECORDS REACH THE LINE AT EVERY ACT, NOT ONLY ON GREEN. A record is an immutable file
+// named by its ULID, so the union of any two sets of records never conflicts, and the
+// integrator adds every record file any worktree of the repository holds, tracked or not,
+// or any local branch holds, that the line lacks, and commits them by pathspec. Records
+// commit on a red as well as a green, because the notes and plan records written while a
+// unit is red are the trace of why it is red; the unit's work stays off the line and the
+// records do not. The plan's close is the last act: the last unit's completed record and
+// the close record are written after the last green, so only a gather at the close puts
+// them on the line, and only after it, with nothing left for lacks to print, does the
+// integrator ask the operator to release. A release of a line missing a record is a
+// release that loses work no other branch holds.
 //
-// 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, and writing the landing of each commit that
+// holds the unit, is the implementer's; the verdict, written to the unit's history before
+// it is returned, is the assayer's; cutting the line, combining, the whole check, the
+// unit's whole or broke written before the report, the records commit at every act 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.
+//
+// THE LEDGER IS WHERE A UNIT STANDS. Each party writes its own event to the unit's history
+// as it happens, so which commit landed a unit, what the assayer found on it and whether
+// it made the whole or broke it are read from `plan show <unit>`; no return, message or
+// memory has to carry them, and the returns stay names.
+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, land, assay, whole, broke @ 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 · cuts line(P) · combines · runs gate · gathers and commits records at every act · asks release⟩
+operator ≜ the human who signs off a release
+achieved : unit → 𝔹 ⟨the assayer's verdict⟩
+base(P) ≜ the commit the units of P are built on ⟨the HEAD of the checkout where P was bound⟩
+line(P) ≜ the integration line of P, branch \`plan/<plan>\` cut at the integrator's first dispatch for P from base(P) ⟨¬ main · \`git worktree add <path> -b plan/<plan> <base>\` · the history the units stand on never conflicts at combination, and the line lacks nothing that branch held when P began · it holds every approved unit AND every design, plan and note record written while P ran, so releasing it loses nothing⟩
+lacks(P) ≜ \`{ git for-each-ref --format='%(refname)' refs/heads | while read -r b; do git ls-tree -r --name-only "$b" records/; done; git worktree list --porcelain | sed -n 's/^worktree //p' | while read -r w; do git -C "$w" ls-files -co --exclude-standard records/; done; } | sort -u | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort)\` ⟨run at the root of the worktree on line(P) · prints each record file that any worktree of the repository, tracked or not, or any local branch holds and line(P) lacks · a record file is \`records/<domain>/<ULID>.json\`, immutable and named by its ULID, so the union of two sets of them never conflicts⟩
+gather(P) ≜ \`git for-each-ref --format='%(refname)' refs/heads | while read -r b; do git ls-tree -r --name-only "$b" records/ | sort | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort) | xargs -r git checkout "$b"; done\` then \`git worktree list --porcelain | sed -n 's/^worktree //p' | while read -r w; do git -C "$w" ls-files -co --exclude-standard records/ | sort | comm -23 - <(git ls-tree -r --name-only HEAD records/ | sort) | while read -r f; do [ "$w/$f" -ef "$f" ] || { mkdir -p "$(dirname "$f")"; cp "$w/$f" "$f"; }; done; done\` then \`git add records/ && { git diff --cached --quiet records/ || git commit -m 'chore(records): <plan> <act>' records/; }\` ⟨run at the root of the worktree on line(P) · adds every record lacks(P) prints, from its branch or its worktree, and commits them by pathspec, records only · <act> is the unit and green or red, or close⟩
+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)⟩
 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 · the first dispatch for P also names base(P)⟩
+first dispatch for bound P ⇒ the integrator cuts line(P) from base(P) ⟨a later dispatch finds line(P) and uses it⟩
+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 ⇒ whole(unit) ∧ gather(P) ∧ report \`whole <unit> of <plan>\` ⟨whole(unit) ≜ line(P) with unit integrated ∧ gate green, recorded by the integrator with the line's commit before the report · the architect sends the report to the planner, which records advance(unit) completed ∧ hands out the newly ready names⟩
+integrate(unit) ∧ ¬ gate green ∨ a merge conflict ⇒ the unit's work OFF line(P) ⟨the merge aborted or the line returned to the commit before the combination⟩ ∧ broke(unit) ∧ gather(P) ∧ report \`red <unit> of <plan>: <failing check>\` ⟨broke(unit) records the failing check before the report · the records written while the unit was red are still committed · the architect sends the report to the implementer that built the unit · the integrator repairs nothing⟩
+∀ event ∈ { land, assay, whole, broke } of unit : written to its history as it happens, by the party it happens to ⟨land ∈ the implementer, for each commit that holds unit · assay ∈ the assayer, before its verdict is returned · whole ∨ broke ∈ the integrator, before its report · none of them a return⟩
+where unit stands ∧ on what it was accepted ⇒ read from show(unit) ⟨its ledger : the commit that landed it, what the assayer found on it, whether it made the whole or broke it · ¬ a message ∧ ¬ an agent's memory⟩
 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) ⇒ the architect routes the close to the integrator ⟨the records written after the last combination, the planner's completed and close records among them, exist only now⟩
+the close routed ⇒ gather(P) ∧ lacks(P) prints nothing ⟨no worktree and no local branch holds a record line(P) lacks⟩ ∧ ask the operator release(P) ⟨the ask comes AFTER the gather · the integrator asks · it never moves main⟩
+deliver ≜ bind ⟨planner⟩ → send ⟨architect, by name⟩ → verify ⟨implementer, writes land⟩ → achieved ⟨assayer, writes assay⟩ → integrate ∧ gate ⟨integrator, once on the combined tree⟩ → whole ∨ broke ⟨integrator writes it⟩ → gather ⟨integrator, at every act : green or red⟩ → advance ⟨planner records completed⟩ → close ⟨planner⟩ → gather ⟨integrator, at the close⟩ → release ⟨operator, asked by the integrator once lacks(P) prints nothing⟩`;
 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 at every act commit the records the line lacks by pathspec, then record the unit whole with the line's commit and report it on green, or on red or a merge conflict leave the unit's work off the line, record the unit broke with the failing check, and report the unit and the failing check. The line is cut at the first dispatch from the commit the plan's units are built on, never from bare main, and it holds the plan's whole work: every approved unit together with every design, plan and note record written while the plan ran, gathered from every worktree of the repository and every local branch, so releasing it loses nothing. Reach for it whenever an achieved unit arrives by name and commit, and when the plan closes: the records written after the last combination (the planner's completed and close records) are gathered and committed at the close, and only then does it ask the operator to release. It reads the loop in order: the architect sends each name and routes the close, the planner binds the plan and records units active and completed and the plan closed, the implementer builds and records the landing of its commit, and the assayer's verdict, recorded by the assayer, the one judgement of a unit, is the acceptance rather than the implementer's return; each party writes its own event to the unit's history as it happens, so where a unit stands is read from \`plan show\` and never from a message; a merge is durability, and neither a merge nor a green check accepts. It 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,yFAAyF;AACzF,0FAA0F;AAC1F,wFAAwF;AACxF,uFAAuF;AACvF,qFAAqF;AACrF,0FAA0F;AAC1F,mEAAmE;AACnE,EAAE;AACF,wFAAwF;AACxF,sFAAsF;AACtF,0FAA0F;AAC1F,wFAAwF;AACxF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,wFAAwF;AACxF,sFAAsF;AACtF,oFAAoF;AACpF,iDAAiD;AACjD,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,eAAe;AACf,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,wDAAwD;AAExD,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wbAsDsb,CAAC;AAE5c,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,uhEAAuhE;IACpiE,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}