@cratylus/canon 0.9.0 → 0.11.0

package/dist/hooks/stance-guardrail.js.map

@@ -1 +1 @@
-{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,mFAAmF;IACnF,+DAA+D;IAC/D,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4tBd;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,yEAAyE;YACzE,sEAAsE;YACtE,0EAA0E;YAC1E,2EAA2E;YAC3E,yEAAyE;YACzE,yEAAyE;YACzE,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsNX,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyLV;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"stance-guardrail.js","sourceRoot":"","sources":["../../src/hooks/stance-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,gFAAgF;AAEhF,wFAAwF;AACxF,0FAA0F;AAC1F,yFAAyF;AACzF,4FAA4F;AAC5F,8FAA8F;AAC9F,6FAA6F;AAC7F,uFAAuF;AACvF,mEAAmE;AACnE,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAEpC,qFAAqF;AACrF,6FAA6F;AAC7F,wFAAwF;AACxF,sFAAsF;AACtF,wFAAwF;AACxF,0FAA0F;AAC1F,sCAAsC;AACtC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;oBAKb,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCvC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,EAAE,EAAE,kBAAkB;IACtB,OAAO,EACL,8UAA8U;IAChV,SAAS,EAAE,SAAS;IACpB,mFAAmF;IACnF,+DAA+D;IAC/D,KAAK,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC1D,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,KAAK,EAAE,qBAAqB;IAC5B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,qBAAqB;YAC/B,UAAU,EAAE,sDAAsD;YAClE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkPb,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAohBf;SACI;QACD;YACE,QAAQ,EAAE,iBAAiB;YAC3B,UAAU,EAAE,kDAAkD;YAC9D,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFd;SACI;QACD;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,KAAK;YACjB,yEAAyE;YACzE,qEAAqE;YACrE,0EAA0E;YAC1E,2EAA2E;YAC3E,yEAAyE;YACzE,yEAAyE;YACzE,EAAE;YACF,mFAAmF;YACnF,kFAAkF;YAClF,8EAA8E;YAC9E,6EAA6E;YAC7E,0EAA0E;YAC1E,wEAAwE;YACxE,iFAAiF;YACjF,0DAA0D;YAC1D,oFAAoF;YACpF,mFAAmF;YACnF,qFAAqF;YACrF,kDAAkD;YAClD,4EAA4E;YAC5E,mFAAmF;YACnF,mFAAmF;YACnF,qFAAqF;YACrF,gFAAgF;YAChF,iFAAiF;YACjF,mFAAmF;YACnF,8EAA8E;YAC9E,iFAAiF;YACjF,iFAAiF;YACjF,0BAA0B;YAC1B,mFAAmF;YACnF,8EAA8E;YAC9E,wEAAwE;YACxE,iFAAiF;YACjF,oFAAoF;YACpF,8EAA8E;YAC9E,iFAAiF;YACjF,+EAA+E;YAC/E,sFAAsF;YACtF,8EAA8E;YAC9E,0EAA0E;YAC1E,gFAAgF;YAChF,qFAAqF;YACrF,mFAAmF;YACnF,iFAAiF;YACjF,4EAA4E;YAC5E,qFAAqF;YACrF,4EAA4E;YAC5E,sFAAsF;YACtF,sFAAsF;YACtF,iFAAiF;YACjF,0EAA0E;YAC1E,+EAA+E;YAC/E,iFAAiF;YACjF,+EAA+E;YAC/E,gFAAgF;YAChF,kEAAkE;YAClE,iFAAiF;YACjF,oFAAoF;YACpF,iFAAiF;YACjF,+EAA+E;YAC/E,kFAAkF;YAClF,kFAAkF;YAClF,+BAA+B;YAC/B,oFAAoF;YACpF,oFAAoF;YACpF,qFAAqF;YACrF,+CAA+C;YAC/C,mFAAmF;YACnF,qFAAqF;YACrF,mFAAmF;YACnF,mCAAmC;YACnC,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAyGgD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFrE;SACI;KACF;CACF,CAAC;AAEF,6FAA6F;AAC7F,8FAA8F;AAC9F,gGAAgG;AAChG,6FAA6F;AAC7F,MAAM,CAAC,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;AAC5D,MAAM,CAAC,MAAM,wBAAwB,GAAG,cAAc,CAAC"}

package/dist/roles/assayer.js

@@ -33,7 +33,9 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 //
 // `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.
+// 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', 'note'],

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,mFAAmF;AACnF,uFAAuF;AACvF,qFAAqF;AACrF,sFAAsF;AACtF,8CAA8C;AAC9C,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,4DAA4D;AAE5D,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"}
+{"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/implementer.js

@@ -21,11 +21,13 @@ import { limitationDisclosure as limitationDisclosure_transparency } from '../di
 // THE BOTTOM RUNG, and the only one whose write layer is the substrate. It carries no
 // 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.
+// discipline to stay inside the boundary: its unit is built on its own branch cut from
+// the plan's line, and while the plan is bound it never commits on main.
 //
 // `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>`, is
+// 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,

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,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,sFAAsF;AACtF,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"}
+{"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,uFAAuF;AACvF,yEAAyE;AACzE,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.js

@@ -11,7 +11,8 @@ import { executableTestOracle as executableTestOracle_selfEvaluation } from '../
 // 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.
+// good intention away from repairing a red on the line. It finds the line the planner's
+// bind cut and cuts no branch of its own, and commits the records that line's worktree holds.
 //
 // `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`,

package/dist/roles/integrator.js.map

@@ -1 +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"}
+{"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,wFAAwF;AACxF,8FAA8F;AAC9F,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

@@ -27,7 +27,8 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 //
 // `system-design` is absent alongside `software-engineering` — this position neither
 // 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.
+// shards it is handed, and the plan's records from binding, which cuts the plan's line, to
+// closing. The integrator, not this position, commits the records it writes on the line.
 export const plannerRole = {
     sign: planner_role,
     // The role declares one skill, `plan`, and is given plan's composition with it

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/deliver/skill.js

@@ -19,23 +19,53 @@ import { plan } from '../plan/skill.js';
 // 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 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.
+// THE LINE IS NOT MAIN, AND IT HAS ONE BIRTH. Bind, the planner's act, cuts the plan's
+// integration line, the branch `plan/<plan>`, from the HEAD of the checkout where bind
+// runs (never from bare main: a line cut from main lacks the history the units stand on,
+// and that history then conflicts at combination) into a worktree at `<main worktree>.plan-<plan>`.
+// The integrator finds that line and cuts nothing: a second cut would compete with the
+// first, and fail on a line that exists. Each unit is built on a branch cut from the line,
+// and while the plan is bound nothing is committed on main, so main carries no unjudged
+// work. 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.
+//
+// RECORDS ARE WRITTEN ON THE LINE AND COMMITTED THERE AT EVERY ACT. While a plan is bound
+// the runtime writes every plan record and every note that blocks the plan or a unit of it
+// into the line's worktree, from whichever checkout the party runs in, so no unit's
+// history forks across checkouts. The runtime commits nothing: the integrator commits what
+// that worktree holds by pathspec at every act, green or red and at the close, the planner's
+// state records included, and the planner, implementer and assayer commit none of their
+// own. 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 commit 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 finding beside the path, a note that
+// blocks nothing, is written where its party runs, so gather adds those from any other
+// worktree or local branch, and lacks stays the release check that prints nothing. A
+// release of a line missing a record is a release that loses work no other branch holds.
 //
 // 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.
+// the plan, which cuts the line, and recording a unit active, completed and the plan closed
+// is the planner's; building on a branch cut from the line 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;
+// finding 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
 yield  ≜ what execution established ∧ ¬ derivable from the design
 P      @ plan
 unit   @ plan
-advance, bind, close, closed, bound @ plan
+advance, bind, close, closed, bound, land, assay, whole, broke @ plan
 accept @ plan ⟨the MECHANICAL half⟩
 outputs @ plan
 artifact : P → ℘(path) ⟨what landed⟩
@@ -44,16 +74,17 @@ conform @ signify
 capture @ note
 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⟩
+implementer : P ⇀ agent ⟨role = implementer · builds and commits its own unit on a branch cut from line(P), never on main⟩
 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⟩
+integrator : P ⇀ agent ⟨role = integrator · one per P · finds line(P), cuts none · combines · runs gate · commits the records line(P) holds and gathers the rest at every act · 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⟩
+line(P) ≜ the integration line of P, branch \`plan/<plan>\`, in a worktree at \`<main worktree>.plan-<plan>\` ⟨¬ main · bind(P) cuts it once, from the HEAD of the checkout where bind runs, and the integrator finds it · while bound(P) every plan record and blocking note about P is written there from any checkout · it holds every approved unit AND every 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) · commits the records that worktree holds, which is every record about P, and first adds any record another worktree or local branch holds and line(P) lacks, a finding beside the path · 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)⟩
-whole(unit) ≜ line(P) with unit integrated ∧ gate green
 defect ≜ ⟨symptom, locus, provenance⟩
 impedes : defect × P → 𝔹
 cost   : act → effort
@@ -66,9 +97,14 @@ release(P) ≜ line(P) reaches main ⟨the operator's sign-off · a pull request
 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⟩
+bound(P) ⇒ bind cut line(P) ∧ the integrator finds it and cuts none ⟨the line has one birth · a worktree the runtime cannot find is a refusal that names the command restoring it⟩
+bound(P) ⇒ ∀ unit ∈ P : built on a branch cut from line(P) ∧ ∄ commit @ main ⟨work ↦ that branch · records ↦ line(P) · main receives line(P) only at release(P)⟩
+bound(P) ⇒ every record about P is written on line(P) from any checkout ∧ the integrator commits them at every act ⟨the planner's state records included · the runtime commits nothing · planner ∧ implementer ∧ assayer commit none of them⟩
 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⟩
+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 ∨ 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⟩
@@ -77,11 +113,12 @@ cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearin
 ∃ 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 : 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⟩`;
+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, are committed 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, cuts line(P)⟩ → send ⟨architect, by name⟩ → verify ⟨implementer on a branch cut from line(P), 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 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.`,
+    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 holds 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 the branch the planner's bind cut, from the HEAD of the checkout where bind ran and never from bare main; the integrator finds it and cuts none, and no agent commits on main while the plan is bound. Every record about the plan is written on the line from any checkout, and it holds the plan's whole work: every approved unit together with every plan and note record written while the plan ran, strays gathered from other worktrees and local branches, 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 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, cutting its line, and records units active and completed and the plan closed, the implementer builds on a branch cut from the line 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,

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

@@ -1 +1 @@
-{"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"}
+{"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,uFAAuF;AACvF,uFAAuF;AACvF,yFAAyF;AACzF,oGAAoG;AACpG,uFAAuF;AACvF,2FAA2F;AAC3F,wFAAwF;AACxF,yFAAyF;AACzF,2FAA2F;AAC3F,wBAAwB;AACxB,EAAE;AACF,0FAA0F;AAC1F,2FAA2F;AAC3F,oFAAoF;AACpF,2FAA2F;AAC3F,6FAA6F;AAC7F,wFAAwF;AACxF,sFAAsF;AACtF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,wFAAwF;AACxF,0FAA0F;AAC1F,uFAAuF;AACvF,qFAAqF;AACrF,yFAAyF;AACzF,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,2FAA2F;AAC3F,wFAAwF;AACxF,kFAAkF;AAClF,yFAAyF;AACzF,2FAA2F;AAC3F,uFAAuF;AACvF,uDAAuD;AACvD,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,wFAAwF;AACxF,wDAAwD;AAExD,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;meAuDie,CAAC;AAEvf,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,mtEAAmtE;IAChuE,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/plan/skill.js

@@ -32,17 +32,17 @@ const LIFECYCLE = {
     unit: { states: ['pending', 'active', 'completed'], satisfies: 'completed' },
 };
 const { plan: PLAN, unit: UNIT } = LIFECYCLE;
-const FORMAL_BLOCK = `shard  @ design
-c      @ design
+const FORMAL_BLOCK = `shard @ design
+c @ design
 anchor @ design
 closure @ design
 withdrawn @ design
-P      ≜ a plan : the units realizing a set of shards
-unit   ≜ a unit of work ⟨unit ∈ P⟩
+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⟩
 States(unit) ≜ { ${UNIT.states.join(', ')} } ⟨in lifecycle order⟩
-state  : P → States(P) ∧ unit → States(unit)
+state : P → States(P) ∧ unit → States(unit)
 bound(P) ⇔ state(P) = ${PLAN.exclusive}
 closed(P) ⇔ state(P) = ${PLAN.final}
 satisfied(unit) ⇔ state(unit) ≽ ${UNIT.satisfies} ⟨reached completion ∨ moved past it⟩
@@ -50,19 +50,19 @@ settled(x) ⇔ x has exactly one current version ⟨x a P ∨ a unit⟩
 live(x) ⇔ settled(x) ∧ that version ¬ a retraction
 diverged(x) ⇔ ¬settled(x) ⟨concurrent sessions wrote x differently ∧ merged · state, ¬ error⟩
 incoherent(P) ⇔ a law below broken across plans ∨ units by a merge ∧ kept on each branch
-R      ⊆ P × P ⟨dependency⟩
+R ⊆ P × P ⟨dependency⟩
 deps(unit) ≜ { u | (unit, u) ∈ R }
 realizes : P → ℘(anchor) ∧ unit → anchor ⟨TOTAL⟩
-pin    : unit → the version of denotes(realizes(unit)) the unit was authored against
+pin : unit → the version of denotes(realizes(unit)) the unit was authored against
 drifted(unit) ⇔ pin(unit) ≠ the one current version of denotes(realizes(unit)) ⟨amended · withdrawn · split into competing versions⟩
 suspect(unit) ⇔ ¬drifted(unit) ∧ ∃ c ∈ closure(denotes(realizes(unit))) : c has more than one current version ∨ withdrawn(c) ∨ c has a version newer than pin(unit)
 static : P → ℘(path)
-refs   : P → ℘(path) ⟨what unit's outputs compile against⟩
+refs : P → ℘(path) ⟨what unit's outputs compile against⟩
 outputs : P → ℘(path)
 footprint : P → ℘(path) ⟨what landing unit actually changed⟩
 occurs : anchor → ℘(path) ⟨every site SPELLING it · the site DEFINING it is ONE⟩
 accept : P → (return → 𝔹) ⟨MECHANICAL only · the semantic half is @ deliver⟩
-pre    : P → return
+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 implementer finishes in one dispatch ⟨DECLARED by the implementer's harness · ¬ a constant here⟩
@@ -71,14 +71,12 @@ slices : P → ℘(℘(P))
 cross(S) ≜ |R ∩ ⋃ { sᵢ × sⱼ | sᵢ, sⱼ ∈ S ∧ i ≠ j }|
 wave(0) ≜ { unit | ∄ u : (unit, u) ∈ R }
 wave(n+1) ≜ { unit | unit ∉ W(n) ∧ ∀ u : (unit, u) ∈ R ⇒ u ∈ W(n) }
-W(n)   ≜ ⋃ { wave(i) | i ≤ n }
-owed   @ note
+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 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 its shards⟩
+ready(unit) ⇔ bound(P) ∧ ¬blocked(unit) ∧ ∄ owed note blocking unit ∨ P ⟨computed, never stored · ready 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 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 ⟨the planner's ∧ the implementer's read · ¬ the architect's⟩
@@ -87,22 +85,22 @@ advance(unit) ≜ \`scripts/plan.mjs advance <unit> --plan <p> --to <state>\`
 retract(unit) ≜ \`scripts/plan.mjs retract <unit> --plan <p>\`
 revise(unit) ≜ \`scripts/plan.mjs revise <unit> --plan <p> [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]…\` ⟨spec(unit) · pin(unit) kept⟩
 revise(P) ≜ \`scripts/plan.mjs revise <plan> [--name <n>] [--realizes <concept>]…\` ⟨name(P) ∨ realizes(P)⟩
-bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P) ∧ the P bound before returns to ${PLAN.states[0]}⟩
+bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P), cuts P's line \`plan/<plan>\` from the HEAD of its checkout into \`<main worktree>.plan-<plan>\`⟩
 close(P) ≜ \`scripts/plan.mjs close <plan>\` ⟨closed(P)⟩
 reconcile(x) ≜ \`scripts/plan.mjs reconcile <unit> --plan <p> [--name <n>] [--realizes <concept>] [--intent <i>] [--static <path>]… [--deps <unit>]… [--outputs <path>]… [--accept <criterion>]… [--state <state>] [--repin]\` ∨ \`scripts/plan.mjs reconcile <plan> [--name <n>] [--realizes <concept>]… [--state <state>]\` ↦ one version superseding every current version of x ⟨each field the versions disagree on is given · a unit whose versions pin differently takes --repin⟩
+land(unit) ≜ \`scripts/plan.mjs land <unit> --plan <p> --commit <c>\`
+assay(unit) ≜ \`scripts/plan.mjs assay <unit> --plan <p> --commit <c> --verdict <achieved|not-achieved> [--missing <part>]…\`
+whole(unit) ≜ \`scripts/plan.mjs whole <unit> --plan <p> --commit <c>\`
+broke(unit) ≜ \`scripts/plan.mjs broke <unit> --plan <p> --check <check>\`
 
-∀ add ∨ advance ∨ retract ∨ revise ∨ bind ∨ close ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
-∀ unit : realizes(unit) = 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⟩
+∀ verb ≠ show : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
+∀ unit : realizes(unit) = the anchor of ONE shard ⟨TOTALITY is the gate · a unit citing no concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
 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⟩
+∀ unit : realizes(unit) = the concept pin(unit) names ∧ realizes(unit) ∈ realizes(P) ⟨a merge breaking it is incoherent(P), reported like the others⟩
 |{ P | bound(P) }| ≤ 1 ⟨held by bind(P), which returns the P bound before⟩
 ∀ n : |{ P | live(P) ∧ name(P) = n }| ≤ 1 ∧ ∀ P : |{ unit ∈ P | live(unit) ∧ name(unit) = n }| ≤ 1
 closed(P) ⇒ name(P) kept ∧ ∄ write to P ∨ any unit ∈ P ⟨closed is final · readable forever⟩
 ¬closed(P) ⇒ revise(P) admitted ⟨its name ∧ its concepts, never its state⟩
-state(P) moves by bind(P) ∨ close(P) alone
-revise routes to revise(unit) ∨ revise(P) by the name it is given ⟨--plan puts a unit's P in view⟩
 ∃ u : live(u) ∧ unit ∈ deps(u) ⇒ ¬ retract(unit)
 advance(unit) ⊨ bound(P) ∧ one step forward in States(unit) ⟨a skip ∨ a step back refuses · a unit of an unbound P is authored ∧ revised, ¬ worked⟩
 ∀ unit : R acyclic ∧ ∀ u ∈ deps(unit) : live(u) ∧ u ∈ P
@@ -111,46 +109,31 @@ add(unit) ⊨ ∀ c ∈ closure(denotes(realizes(unit))) : c has exactly one cur
 pin(unit) retaken ⇔ \`scripts/plan.mjs revise <unit> --plan <p> --repin --reason <why>\` ⟨the ONLY way · never a side effect of editing spec(unit)⟩
 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 ⇔ 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⟩
+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 ⇔ 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 ⊨ 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) 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)) ⟨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⟩
+∀ 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 ⟨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⟩
-∀ unit : ∃ r : ¬accept(unit)(r) ∧ ¬accept(unit)(pre(unit)) ⟨criteria that cannot FAIL, ∧ that
-    already pass before the work, test nothing⟩
+∀ unit : effort(unit) ≤ capacity ⟨a unit past capacity, or an implementer exhausted mid-unit (effort mis-estimated), hands its successor a re-read, ¬ progress⟩
+effort(unit) > capacity ⇒ split on factors(denotes(realizes(unit))) ⟨each part realizes a factor⟩ ≺ redispatch ; factors = ∅ ⇒ SURFACE ⟨a primitive no implementer finishes is ¬ primitive @ design⟩
+∀ unit : footprint(unit) ⊆ outputs(unit) ⟨outputs IS the contention set ∴ an under-declared array silently voids every disjointness proof above⟩
+∀ unit : occurs(realizes(unit)) ⊆ outputs(unit) ⟨a unit's footprint is its REFERENCE set, ¬ its definition site · resolve occurs BEFORE declaring outputs⟩
+∀ 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 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⟩
+∀ 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⟩
 ∀ unit : reach-leg(unit) ⊨ print(denominator) ⟨∄ denominator ⇒ found-nothing ≡ could-not-look⟩
 ∀ unit : conform(spec(unit))
-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⟩`;
+plan ≜ the planner's procedure : take(shards) → census ⟨delegable⟩ → slice(shards) → add(∀ unit) ⟨spec ∧ pin⟩ → ratify @ planner → bind(P) ⟨cuts the line, 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 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.`,
+    description: `use this skill to decompose the shards a design hands down into MECE units of work — each realizing exactly one shard and citing the single concept it realizes, with its dependencies, declared outputs and mechanical acceptance criteria — sliced on the design's seams rather than on file adjacency, and ordered into waves whose outputs are disjoint so they dispatch concurrently without contending. Reach for it after a design exists and before any work is dispatched. A unit that cites no concept is refused; a shard that cannot be planned as handed down is surfaced, never silently redrawn. It also carries the verbs that write a unit's ledger.`,
     formalBlock: FORMAL_BLOCK,
     runtime: { capability: 'plan', configuration: LIFECYCLE },
     composition: () => [design, note],

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

@@ -1 +1 @@
-{"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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDA8BK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,4BAA4B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oBAAoB,IAAI,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gNAuDiE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,oHAAoH,IAAI,CAAC,SAAS,mNAAsO,CAAC;AAEvkB,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,uoBAAuoB;IACppB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE;IACzD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;IACjC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {
@@ -21,8 +21,8 @@
     "@cratylus/schema": "0.6.0"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.11.0",
-    "@cratylus/runtime": "0.6.0",
+    "@cratylus/forge": "0.11.3",
+    "@cratylus/runtime": "0.8.0",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",