@cratylus/canon 0.10.0 → 0.11.1

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

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

package/dist/roles/implementer.js

@@ -21,7 +21,8 @@ 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 in its own isolated worktree
+// off 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

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,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"}
+{"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,yFAAyF;AACzF,6EAA6E;AAC7E,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":"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,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,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,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACtG,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,YAAY,IAAI,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AACzF,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,+EAA+E;AAC/E,yDAAyD;AACzD,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,uEAAuE;AAEvE,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,+EAA+E;IAC/E,qFAAqF;IACrF,0EAA0E;IAC1E,uDAAuD;IACvD,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,8EAA8E;QAC9E,kFAAkF;QAClF,YAAY;QACZ,YAAY,EAAE,kCAAkC;QAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,mFAAmF;QACnF,mEAAmE;QACnE,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;YACzB,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,kCAAkC;YAClC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kFAAkF;QAClF,sEAAsE;QACtE,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,uBAAuB;QAChC,iBAAiB,EAAE,8BAA8B;QACjD,WAAW,EAAE,oBAAoB;QACjC,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.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,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,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,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACtG,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,YAAY,IAAI,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AACzF,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,+EAA+E;AAC/E,yDAAyD;AACzD,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,2FAA2F;AAC3F,yFAAyF;AAEzF,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,+EAA+E;IAC/E,qFAAqF;IACrF,0EAA0E;IAC1E,uDAAuD;IACvD,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,8EAA8E;QAC9E,kFAAkF;QAClF,YAAY;QACZ,YAAY,EAAE,kCAAkC;QAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,mFAAmF;QACnF,mEAAmE;QACnE,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;YACzB,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,kCAAkC;YAClC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,kFAAkF;QAClF,sEAAsE;QACtE,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,uBAAuB;QAChC,iBAAiB,EAAE,8BAA8B;QACjD,WAAW,EAAE,oBAAoB;QACjC,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}

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

@@ -9,11 +9,11 @@ description     ≜ fm's reconstruction-grade one-liner ; { description , name }
 H1              ≜ the skill name, a VERB, fires on its own @ selection ; body ≺ H1 dropped by composer
 formula         ≜ the first prose \`≜\` line, consumed as the composition formula
 Bindings        ≜ a prose \`Bindings: composes <a> · <b>.\` line, boundary-binds live sibling deps
-block           ≜ the self-sufficient set-builder block @ formalize : declarations above \`=== … ===\`, laws below, no prose, σ* density
-xref            ≜ a sibling ∨ corpus concept, cited once by its bare σ* anchor
+block           ≜ the self-sufficient set-builder block @ formalize : declarations above \`=== … ===\`, laws below, no prose, dense notation
+xref            ≜ a sibling ∨ corpus concept, cited once by its bare name ⟨a core agent dimension name or value by its σ* anchor · any other term as the industry's own⟩
 gate            ∈ { schema, references, fences, symbols, verbatim-ref-free, operative, provenance } ⟨corpus-scoped : symbols · self-sufficiency span all cells⟩
 verify          ≜ the FULL corpus suite (\`pnpm test\`) as the shard-completion gate : per-cell PASS ≠ corpus PASS ∴ run the whole suite, ¬ the cell's own targeted check alone
-green           ≜ ∀ gate PASS reached by fixing → the FITTER sign ⟨declare the fittest glyph + cold-verify · ∨ resolve it to its decodable word⟩, never by degrading the sign to appease a gate ⟨gate = decodability registry, ¬ expression cap⟩
+green           ≜ ∀ gate PASS reached by fixing → the FITTER sign ⟨declare the fittest glyph in T · ∨ resolve it to its decodable word⟩, never by degrading the sign to appease a gate ⟨gate = decodability registry, ¬ expression cap⟩
 
 self-sufficient(block) ⇔ every term defined in-cell ∧ only live siblings named in prose, never restated
 ∀ glyph ∈ fences(cell) : glyph ∈ symbol-table ∪ definienda(cell) ∪ exemptions(Greek · subscript · box-drawing · em-dash)

package/dist/skills/deliver/skill.js

@@ -19,35 +19,42 @@ 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, 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.
+// THE LINE IS NOT MAIN, AND IT HAS ONE BIRTH. Bind, the planner's act, brings the plan's
+// integration line into being, from the commit the plan's units stand on (never from bare
+// main: a line cut from main lacks the history the units stand on, and that history then
+// conflicts at combination). 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 in its
+// own isolated worktree off the line, and while the plan is bound nothing is committed on
+// main, so main carries no unjudged work; how an implementer makes and uses that worktree
+// is its own competence, and nothing here teaches it. 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 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.
+// 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 finds none. 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, 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 plan, which cuts the line, and recording a unit active, completed and the plan closed
+// is the planner's; building in its own worktree off 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
@@ -67,15 +74,14 @@ 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 in its own worktree off line(P), never on main⟩
 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⟩
+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⟩
-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⟩
+line(P) ≜ the integration line of P ⟨¬ main · bind(P) brings it into being once, from the commit the plan's units stand on, 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) ≜ every record file that any worktree of the repository, tracked or not, or any local branch holds and line(P) lacks ⟨checked from line(P)'s own worktree · it is the release check and must find none · 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) ≜ every record file that another worktree or local branch holds and line(P) lacks, brought onto line(P), and then every record the worktree of line(P) holds committed ⟨done from that worktree · the records committed are every record about P, a finding beside the path among them · by pathspec, records only · the commit message is \`chore(records): <plan> <act>\`, and <act> is the unit and green or red, or close · nothing is committed when there is nothing to add⟩
 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)⟩
@@ -90,8 +96,10 @@ release(P) ≜ line(P) reaches main ⟨the operator's sign-off · a pull request
 ∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
 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⟩
+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 line the runtime cannot find is a refusal that says what is missing⟩
+bound(P) ⇒ ∀ unit ∈ P : built in its own worktree off line(P) ∧ ∄ commit @ main ⟨work ↦ that worktree · 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 ⇒ 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⟩
@@ -105,12 +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) ⇒ 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⟩`;
+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) finds none ⟨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, brings line(P) into being⟩ → send ⟨architect, by name⟩ → verify ⟨implementer in its own worktree off 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) finds none⟩`;
 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 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.`,
+    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 integration line the planner's bind brings into being, 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, bringing its line into being, and records units active and completed and the plan closed, the implementer builds in its own worktree off 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,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"}
+{"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,yFAAyF;AACzF,2FAA2F;AAC3F,0FAA0F;AAC1F,0FAA0F;AAC1F,0FAA0F;AAC1F,yFAAyF;AACzF,sFAAsF;AACtF,2EAA2E;AAC3E,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,iFAAiF;AACjF,yFAAyF;AACzF,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,8FAA8F;AAC9F,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+eAuD6e,CAAC;AAEngB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,ysEAAysE;IACttE,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;IACvC,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/design/skill.js

@@ -15,7 +15,7 @@ import { primePrinciple } from '../../genus/prime-principle.js';
 // implementer that satisfies the letter passes while the system stays incoherent. A
 // second, independent statement of what should exist is what makes validation an
 // operation rather than a re-reading of the claim. That statement is this lattice.
-const FORMAL_BLOCK = `anchor ≜ a concept's canonical sign @ signify
+const FORMAL_BLOCK = `anchor ≜ a concept's name ⟨the project's own · answers to no cold decode⟩
 gloss  ≜ what a concept IS ⟨one line · reconstruction-grade⟩
 C      ≜ the concept lattice ⟨the project's durative model⟩
 c      ≜ a concept ⟨c ∈ C⟩
@@ -25,8 +25,6 @@ primitive(c) ⇔ factors(c) = ∅ ⟨held by VALUE ⟨anchor · gloss⟩⟩
 composite(c) ⇔ factors(c) ≠ ∅ ⟨held by REFERENCE ⟨anchor · factor-anchors⟩ @ materialize⟩
 closure : C → ℘(C) ⟨closure(c) ≜ { c } ∪ ⋃ { closure(f) | f ∈ factors(c) }⟩
 denotes : anchor ⇀ C
-σ*      @ signify
-conform @ signify
 shard(c) ≜ ⟨ c , closure(c) ⟩ handed down ⟨what a planner is handed · one concept with everything it stands on⟩
 cut    ≜ the architect's choice of shards to hand the planner
 history(c) ≜ every version ∧ retraction of c, in order ⟨resident · ¬ deleted⟩
@@ -48,7 +46,7 @@ trace(c) ≜ \`scripts/design.mjs trace <concept>\` ↦ ⟨history(c), closure(c
 ∀ define ∨ supersede ∨ retract ∨ reconcile : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
 ∀ c : ∃! anchor(c) ∧ ∀ a ∈ dom(denotes) : ∃! denotes(a) ⟨one live concept per anchor⟩
 withdrawn(c) ⇒ anchor(c) held until supersede(c) reinstates it
-∀ c : conform(anchor(c)) ∧ gloss(c) ≠ ∅
+∀ c : gloss(c) ≠ ∅
 ∀ c : closure(c) finite ⟨factors acyclic ∴ a lattice, ¬ a graph⟩ ∧ ∀ f ∈ factors(c) : live(f)
 ∃ d : live(d) ∧ c ∈ factors(d) ⇒ ¬ retract(c) ⟨what live concepts factor on cannot be withdrawn⟩
 amend(C) ≜ supersede ⟨∄ overwrite ; a live c is NEVER edited in place⟩
@@ -84,7 +82,7 @@ the bound plan found built on a shard c that is itself wrong ⇒ in order ⟨sel
      amend waits · an obligation standing between an agent and closing its work always loses · measured 0 of 25⟩
 design ⊨ ¬ delegable ⟨a subagent starts blank ∧ a design authored by several
     fragments BY CONSTRUCTION⟩
-design ≜ conceptualize(intent) → signify(·) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
+design ≜ conceptualize(intent) → materialize(·) → define(c) ∨ supersede(c) → C → cut(C)`;
 export const design = {
     name: 'design',
     description: `use this skill to build and hold a project's DURATIVE conceptual model — the one artifact that outlives every plan: each concept's anchor, gloss and factorization, amended only by append-only supersession, and cut into shards a planner can take, each stating what and why, never how. Its verbs show the design or one concept, define, amend, retract and reconcile a concept, and trace how one came to be, what it stands on and what stands on it. Reach for it FIRST on any long-horizon effort, before any work is decomposed, and again whenever execution or the operator establishes something the model does not yet hold: every such input is a hypothesis the holder rectifies first, and a survivor bearing on a shard a bound plan realizes is held as a note until that plan completes while any other is amended at once, and a plan found built on a wrong shard stops until the shard is corrected once and the plan re-planned. It is what acceptance is judged against, so without it verification has no referent and degrades into re-reading the implementer's own claim.`,

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

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

package/dist/skills/exemplify/skill.js

@@ -18,23 +18,24 @@ const FORMAL_BLOCK = `concept-record     ≜ ⟨ gloss , anchor? , factorization
 sources            ≜ input material @ conceptualize ⟨the corpus D is drawn OVER, ¬ D itself⟩
 C                  ≜ concept lattice @ conceptualize
 produce            : sources → concept-record @ conceptualize
-name               : concept-record → concept-record @ signify
+name               : concept-record → concept-record @ signify ⟨a core name or value takes its σ* anchor · any other term keeps the industry's own⟩
 realize            : concept-record → concept-record @ materialize
 REC                : concept-record → concept-record @ materialize
 R_cold(f)          ≜ the isolated cold-blind decode of fragment f (a naive reader, zero project-K, from f's signifiers + inline ≜ alone)
 body(k)            ≜ cell k's authored surface ⟨front-matter excluded⟩
 decode_warm(f | K) ≜ fragment f's warm decode, reader free to consult K
 K                  ≜ project-K, the warm knowledge (project corpus) a reader already holds
+core               ≜ the corpus's core agent dimension names and values ⟨every other cell answers to no cold decode⟩
 R_cold, decode_warm, coldpass, K @ cold-decode-oracle
 minimal            @ signify
 conform            @ signify
-Cells              ≜ every authored cell, self included
+Cells              ≜ the authored cells of the corpus exemplified, self included
 fragment_digest(f) ≜ digest( trim( collapse-whitespace( NFC(f) ) ) )
 manifest           ≜ { source , exemplified_at , reader , routes[⟨fragment_digest, idea_gloss, home_slug, disposition, rank⟩] , delta[⟨fragment_digest, idea_gloss⟩] }
 
 realized(k) ⇔ factorization(k) ≠ ⊥
 coldpass(k) ⇔ R_cold(body(k)) ≅ gloss(k) ∧ decode_warm(body(k) | K) ≅ R_cold(body(k))
-valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ coldpass(k)
+valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ (k ∈ core ⇒ coldpass(k))
 produce ↦ gloss ; name ↦ anchor ; realize ↦ factorization
 ∀ k ∈ Cells : accept(k) defined
 disposition ∈ { reuse, mint }
@@ -48,7 +49,7 @@ accept(k)    ≜ k , valid(k)
 accept(k)    ≜ ⊥ , ¬valid(k)`;
 export const exemplify = {
     name: 'exemplify',
-    description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept; emits the R3 routing manifest that catches the dropped idea.`,
+    description: `optimize a context corpus into a canonical semantic factorization — compose produce → name → realize over the one concept-record, then gate on accept, cold-decoding only the core agent dimension names and values; emits the R3 routing manifest that catches the dropped idea.`,
     formalBlock: FORMAL_BLOCK,
     composition: () => [],
     preamble: primePrinciple,

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,qNAAqN;IAClO,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/exemplify/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGhE,4CAA4C;AAC5C,EAAE;AACF,wGAAwG;AACxG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgC2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,mRAAmR;IAChS,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/formalize/skill.js

@@ -3,21 +3,18 @@ import { conceptualize } from '../conceptualize/skill.js';
 import { signify } from '../signify/skill.js';
 export const formalize = {
     name: 'formalize',
-    description: `use this skill to convert prose — especially of a process or skill — into a self-sufficient set-builder block under self-sufficient-formalism: conceptualize the prose to its entities/operations/laws, signify each as a symbol (minting or boundary-binding to an anchor), and emit declarations-above / laws-below with no explanatory prose; accept only on round-trip equivalent-or-better.`,
+    description: `use this skill to convert prose — especially of a process or skill — into a self-sufficient set-builder block under self-sufficient-formalism: conceptualize the prose to its entities/operations/laws, name each as a symbol (a core agent dimension name or value by its signify anchor, minted or boundary-bound; any other term as the industry's own), and emit declarations-above / laws-below with no explanatory prose; accept only on round-trip equivalent-or-better.`,
     formalBlock: `prose ≜ the source text
 E ≜ entities(prose) ; O ≜ operations(prose) ; L ≜ laws(prose)
 
 T ≜ the declared notation table @ src/operator-lexicon.ts
-η : E ∪ O ⇀ symbols @ signify
+η : E ∪ O ⇀ symbols ⟨core agent dimension names and values @ signify · every other term the industry's own⟩
 β ≜ { s | s imported, its anchor cited once in adjacent notation }
 ι ≜ { s | s resolved from invocation context }
 
-σ* ≜ signify's fittest sign
-
 B ≜ formalize(prose) such that :
     ∀ e ∈ E      : signature(η(e)) ∈ B
     ∀ o ∈ O ∪ L  : law(η(o)) ∈ B
-    ∀ line ∈ B : line = σ*(its concept)
 
 Dfn ≜ { s | a line of B defines s }
 closed(B)   ⇔ symbols(B) ⊆ T ∪ Dfn ∪ β ∪ ι
@@ -27,7 +24,7 @@ self-sufficient(B) ⇔ closed(B) ∧ complete(B) ∧ ordered(B)
 gloss(B) ≜ prose of B beyond β ∪ ι ; gloss(B) ≠ ∅ ⇒ ¬complete(B)
 ¬self-sufficient(B) ⇒ ⊥
 
-σ*(c) ∉ T ⇒ extend T with σ*(c) ⟨cold-verify⟩ ; ¬ degrade c to a weaker α ∈ T ∵ α ≠ σ*(c) ⟨llm-native⟩
+s ∉ T ⇒ extend T with s ; ¬ degrade the notation to a weaker one already in T ⟨llm-native · a block's notation answers to no cold decode⟩
 
 reconstruct(B) ≽ prose
 reconstruct(B) ⋡ prose ⇒ ⊥`,

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,kYAAkY;IAC/Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0B+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/formalize/skill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,idAAid;IAC9d,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;2BAuB+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,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,7 +85,7 @@ 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)⟩
+bind(P) ≜ \`scripts/plan.mjs bind <plan>\` ⟨bound(P), brings P's integration line into being, once⟩
 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>\`
@@ -96,11 +94,9 @@ whole(unit) ≜ \`scripts/plan.mjs whole <unit> --plan <p> --commit <c>\`
 broke(unit) ≜ \`scripts/plan.mjs broke <unit> --plan <p> --check <check>\`
 
 ∀ verb ≠ show : \`--author <who> --reason <why> --cause <what caused it>\` ⟨a set-valued flag repeats, one member each⟩
-∀ unit : realizes(unit) = the anchor of ONE shard ⟨TOTALITY is the gate · a unit citing no
-    concept is work whose purpose cannot be stated ∴ REFUSED at authoring, ¬ warned⟩
+∀ unit : 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⟩
@@ -113,41 +109,28 @@ 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, 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⟩
+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 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.`,

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iMAqEkD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;8CACjK,IAAI,CAAC,SAAS;6JACoH,CAAC;AAEjL,MAAM,CAAC,MAAM,IAAI,GAAU;IACzB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,uoBAAuoB;IACppB,WAAW,EAAE,YAAY;IACzB,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE;IACzD,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;IACjC,QAAQ,EAAE,cAAc;CACzB,CAAC"}
+{"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"}