@cratylus/canon 0.20.0 → 0.22.0

package/dist/roles/test-engineer.js

@@ -0,0 +1,61 @@
+// The test engineer: writes an acceptance test for each example and gives the verdict
+// whether the realization passes. It states only where cratylus departs from the
+// industry's test engineer.
+import { examples } from '../factors/assignment/examples.js';
+import { missionCommand } from '../factors/autonomy/mission-command.js';
+import { decisionRationale } from '../factors/communication-style/decision-rationale.js';
+import { maintenance } from '../factors/communication-style/maintenance.js';
+import { plain } from '../factors/communication-style/plain.js';
+import { decides } from '../factors/decision-rights/decides.js';
+import { input } from '../factors/decision-rights/input.js';
+import { acceptanceTests } from '../factors/deliverable/acceptance-tests.js';
+import { inUse } from '../factors/evaluation/in-use.js';
+import { honesty } from '../factors/guardrails/honesty.js';
+import { domainModel } from '../factors/memory/domain-model.js';
+import { frontierOtherFamily } from '../factors/model/frontier-other-family.js';
+import { high } from '../factors/model/high.js';
+import { optimize } from '../factors/objective/optimize.js';
+import { testEngineer } from '../factors/role/test-engineer.js';
+export const testEngineerRole = {
+    name: 'test-engineer',
+    description: 'Writes an acceptance test for each example and reports whether the realization passes.',
+    mark: { emoji: '🧪', hue: 'green' },
+    values: {
+        role: [testEngineer],
+        objective: [{ value: optimize, slot: 'stopping-rule' }],
+        expertise: [],
+        procedure: [],
+        stance: [],
+        communicationStyle: [
+            { value: plain, slot: 'register' },
+            { value: maintenance, slot: 'density' },
+            { value: decisionRationale, slot: 'rationale' },
+        ],
+        decisionRights: [
+            { value: input, slot: 'intent' },
+            { value: input, slot: 'priority' },
+            { value: input, slot: 'meaning' },
+            { value: input, slot: 'constraint' },
+            { value: decides, slot: 'realization', note: 'its acceptance tests' },
+            {
+                value: decides,
+                slot: 'verdict',
+                note: 'whether the realization passes its acceptance tests',
+            },
+            { value: input, slot: 'release' },
+        ],
+        autonomy: [missionCommand],
+        perceptionScope: [],
+        actionScope: [],
+        model: [
+            { value: frontierOtherFamily, slot: 'tier' },
+            { value: high, slot: 'effort' },
+        ],
+        memory: [domainModel],
+        assignment: [examples],
+        deliverable: [acceptanceTests],
+        guardrails: [honesty],
+        evaluation: [inUse],
+    },
+};
+//# sourceMappingURL=test-engineer.js.map

package/dist/roles/test-engineer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-engineer.js","sourceRoot":"","sources":["../../src/roles/test-engineer.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,iFAAiF;AACjF,4BAA4B;AAG5B,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sDAAsD,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,qCAAqC,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,MAAM,CAAC,MAAM,gBAAgB,GAAgB;IAC3C,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,wFAAwF;IAC1F,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE;IACnC,MAAM,EAAE;QACN,IAAI,EAAE,CAAC,YAAY,CAAC;QACpB,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QACvD,SAAS,EAAE,EAAE;QACb,SAAS,EAAE,EAAE;QACb,MAAM,EAAE,EAAE;QACV,kBAAkB,EAAE;YAClB,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;YAClC,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;YACvC,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,WAAW,EAAE;SAChD;QACD,cAAc,EAAE;YACd,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE;YAChC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;YAClC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE;YACjC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE;YACpC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,sBAAsB,EAAE;YACrE;gBACE,KAAK,EAAE,OAAO;gBACd,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,qDAAqD;aAC5D;YACD,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE;SAClC;QACD,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,eAAe,EAAE,EAAE;QACnB,WAAW,EAAE,EAAE;QACf,KAAK,EAAE;YACL,EAAE,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE;YAC5C,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE;SAChC;QACD,MAAM,EAAE,CAAC,WAAW,CAAC;QACrB,UAAU,EAAE,CAAC,QAAQ,CAAC;QACtB,WAAW,EAAE,CAAC,eAAe,CAAC;QAC9B,UAAU,EAAE,CAAC,OAAO,CAAC;QACrB,UAAU,EAAE,CAAC,KAAK,CAAC;KACpB;CACF,CAAC"}

package/dist/rules/behaviour-driven-development.d.ts

@@ -0,0 +1,3 @@
+import type { Ruleset } from '@cratylus/schema';
+/** Behaviour-driven development, adopted by its name. */
+export declare const behaviourDrivenDevelopment: Ruleset;

package/dist/rules/behaviour-driven-development.js

@@ -0,0 +1,14 @@
+/** Behaviour-driven development, adopted by its name. */
+export const behaviourDrivenDevelopment = {
+    name: 'behaviour-driven-development',
+    description: "Adopts behaviour-driven development as the project's practice.",
+    rules: [
+        {
+            name: 'behaviour-driven-development-adopted',
+            description: 'The project practises behaviour-driven development.',
+            statement: 'This project practises behaviour-driven development.',
+            why: "Its name carries the practice whole, each role's participation included.",
+        },
+    ],
+};
+//# sourceMappingURL=behaviour-driven-development.js.map

package/dist/rules/behaviour-driven-development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviour-driven-development.js","sourceRoot":"","sources":["../../src/rules/behaviour-driven-development.ts"],"names":[],"mappings":"AAEA,yDAAyD;AACzD,MAAM,CAAC,MAAM,0BAA0B,GAAY;IACjD,IAAI,EAAE,8BAA8B;IACpC,WAAW,EAAE,gEAAgE;IAC7E,KAAK,EAAE;QACL;YACE,IAAI,EAAE,sCAAsC;YAC5C,WAAW,EAAE,qDAAqD;YAClE,SAAS,EAAE,sDAAsD;YACjE,GAAG,EAAE,0EAA0E;SAChF;KACF;CACF,CAAC"}

package/dist/rules/commit-discipline.js

@@ -6,19 +6,19 @@ export const commitDiscipline = {
         {
             name: 'commit-discipline-own-paths',
             description: 'Stage and commit the paths you changed, by name.',
-            convention: 'Stage and commit the paths you changed yourself, naming each one, and leave every other change in the working tree as it is.',
+            statement: 'Stage and commit the paths you changed yourself, naming each one, and leave every other change in the working tree as it is.',
             why: 'The working tree may hold other people’s work in progress; naming your own paths keeps each commit to exactly the change it describes.',
         },
         {
             name: 'commit-discipline-natural-boundaries',
             description: 'Commit each coherent step once it is done and its checks pass.',
-            convention: 'Commit at each natural boundary — a coherent step finished and its checks passing — as you go, without waiting to be asked.',
+            statement: 'Commit at each natural boundary — a coherent step finished and its checks passing — as you go, without waiting to be asked.',
             why: 'Each commit is then one reviewable, revertable step, and finished work is never held only in a working tree.',
         },
         {
             name: 'commit-discipline-shared-history',
             description: 'Add new commits to shared history; published commits stay as they are.',
-            convention: 'Add to the shared history with new commits, and keep the commits others have already received as they are.',
+            statement: 'Add to the shared history with new commits, and keep the commits others have already received as they are.',
             why: 'Everyone working from the shared history can rely on what they have pulled; rewriting it breaks their clones and loses the record.',
         },
     ],

package/dist/rules/commit-discipline.js.map

@@ -1 +1 @@
-{"version":3,"file":"commit-discipline.js","sourceRoot":"","sources":["../../src/rules/commit-discipline.ts"],"names":[],"mappings":"AAEA,sEAAsE;AACtE,MAAM,CAAC,MAAM,gBAAgB,GAAY;IACvC,IAAI,EAAE,mBAAmB;IACzB,WAAW,EACT,yFAAyF;IAC3F,KAAK,EAAE;QACL;YACE,IAAI,EAAE,6BAA6B;YACnC,WAAW,EAAE,kDAAkD;YAC/D,UAAU,EACR,8HAA8H;YAChI,GAAG,EAAE,wIAAwI;SAC9I;QACD;YACE,IAAI,EAAE,sCAAsC;YAC5C,WAAW,EACT,gEAAgE;YAClE,UAAU,EACR,6HAA6H;YAC/H,GAAG,EAAE,8GAA8G;SACpH;QACD;YACE,IAAI,EAAE,kCAAkC;YACxC,WAAW,EACT,wEAAwE;YAC1E,UAAU,EACR,4GAA4G;YAC9G,GAAG,EAAE,oIAAoI;SAC1I;KACF;CACF,CAAC"}
+{"version":3,"file":"commit-discipline.js","sourceRoot":"","sources":["../../src/rules/commit-discipline.ts"],"names":[],"mappings":"AAEA,sEAAsE;AACtE,MAAM,CAAC,MAAM,gBAAgB,GAAY;IACvC,IAAI,EAAE,mBAAmB;IACzB,WAAW,EACT,yFAAyF;IAC3F,KAAK,EAAE;QACL;YACE,IAAI,EAAE,6BAA6B;YACnC,WAAW,EAAE,kDAAkD;YAC/D,SAAS,EACP,8HAA8H;YAChI,GAAG,EAAE,wIAAwI;SAC9I;QACD;YACE,IAAI,EAAE,sCAAsC;YAC5C,WAAW,EACT,gEAAgE;YAClE,SAAS,EACP,6HAA6H;YAC/H,GAAG,EAAE,8GAA8G;SACpH;QACD;YACE,IAAI,EAAE,kCAAkC;YACxC,WAAW,EACT,wEAAwE;YAC1E,SAAS,EACP,4GAA4G;YAC9G,GAAG,EAAE,oIAAoI;SAC1I;KACF;CACF,CAAC"}

package/dist/rules/conventional-commits.js

@@ -6,31 +6,31 @@ export const conventionalCommits = {
         {
             name: 'conventional-commits-structure',
             description: 'A commit message is a typed header, then an optional body and footers.',
-            convention: 'Structure every commit message as `<type>[optional scope]: <description>`, then optionally a body after one blank line, then optionally one or more footers after one blank line. The description follows the colon and space directly and summarises the change.',
+            statement: 'Structure every commit message as `<type>[optional scope]: <description>`, then optionally a body after one blank line, then optionally one or more footers after one blank line. The description follows the colon and space directly and summarises the change.',
             why: 'A structured history can be read by people and parsed by tools: changelogs and the next version number are derived from it.',
         },
         {
             name: 'conventional-commits-types',
             description: 'feat adds a feature, fix patches a bug; other types are allowed.',
-            convention: 'Use the type `feat` for a commit that adds a feature (it correlates with a MINOR version) and `fix` for one that fixes a bug (it correlates with a PATCH version). Other types, such as `build`, `chore`, `ci`, `docs`, `style`, `refactor`, `perf` and `test`, describe changes that are neither.',
+            statement: 'Use the type `feat` for a commit that adds a feature (it correlates with a MINOR version) and `fix` for one that fixes a bug (it correlates with a PATCH version). Other types, such as `build`, `chore`, `ci`, `docs`, `style`, `refactor`, `perf` and `test`, describe changes that are neither.',
             why: 'The type says what kind of change a commit is, which is what decides how it affects the version and where it belongs in a changelog.',
         },
         {
             name: 'conventional-commits-scope',
             description: 'A scope names the section of the codebase, in parentheses.',
-            convention: 'A scope may follow the type: a noun in parentheses naming the section of the codebase the commit changes, such as `fix(parser):`.',
+            statement: 'A scope may follow the type: a noun in parentheses naming the section of the codebase the commit changes, such as `fix(parser):`.',
             why: 'It locates the change at a glance and lets history be filtered by area.',
         },
         {
             name: 'conventional-commits-breaking-changes',
             description: 'Mark a breaking change with ! or a BREAKING CHANGE footer.',
-            convention: 'Mark a commit that breaks the API with `!` immediately before the colon, `feat(api)!: …`, or with a footer `BREAKING CHANGE: <description>`, or both. Where `!` marks it and no `BREAKING CHANGE` footer is given, the commit description describes the breaking change. A breaking change correlates with a MAJOR version, whatever its type.',
+            statement: 'Mark a commit that breaks the API with `!` immediately before the colon, `feat(api)!: …`, or with a footer `BREAKING CHANGE: <description>`, or both. Where `!` marks it and no `BREAKING CHANGE` footer is given, the commit description describes the breaking change. A breaking change correlates with a MAJOR version, whatever its type.',
             why: 'Consumers and release tooling learn from the commit itself that upgrading needs their attention.',
         },
         {
             name: 'conventional-commits-footers',
             description: 'Footers are git trailers: a token, then ": " or " #", then a value.',
-            convention: 'Write each footer as a token, then `: ` or ` #`, then a value, in the manner of git trailers, such as `Reviewed-by: Z` or `Refs #133`. A token uses `-` in place of spaces; `BREAKING CHANGE` is the one token written with a space, and `BREAKING-CHANGE` means the same.',
+            statement: 'Write each footer as a token, then `: ` or ` #`, then a value, in the manner of git trailers, such as `Reviewed-by: Z` or `Refs #133`. A token uses `-` in place of spaces; `BREAKING CHANGE` is the one token written with a space, and `BREAKING-CHANGE` means the same.',
             why: 'Footers in the git trailer form are parsed by git and by release tooling alike.',
         },
     ],

package/dist/rules/conventional-commits.js.map

@@ -1 +1 @@
-{"version":3,"file":"conventional-commits.js","sourceRoot":"","sources":["../../src/rules/conventional-commits.ts"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,MAAM,CAAC,MAAM,mBAAmB,GAAY;IAC1C,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EACT,qGAAqG;IACvG,KAAK,EAAE;QACL;YACE,IAAI,EAAE,gCAAgC;YACtC,WAAW,EACT,wEAAwE;YAC1E,UAAU,EACR,mQAAmQ;YACrQ,GAAG,EAAE,6HAA6H;SACnI;QACD;YACE,IAAI,EAAE,4BAA4B;YAClC,WAAW,EACT,kEAAkE;YACpE,UAAU,EACR,oSAAoS;YACtS,GAAG,EAAE,sIAAsI;SAC5I;QACD;YACE,IAAI,EAAE,4BAA4B;YAClC,WAAW,EAAE,4DAA4D;YACzE,UAAU,EACR,mIAAmI;YACrI,GAAG,EAAE,yEAAyE;SAC/E;QACD;YACE,IAAI,EAAE,uCAAuC;YAC7C,WAAW,EAAE,4DAA4D;YACzE,UAAU,EACR,gVAAgV;YAClV,GAAG,EAAE,kGAAkG;SACxG;QACD;YACE,IAAI,EAAE,8BAA8B;YACpC,WAAW,EACT,qEAAqE;YACvE,UAAU,EACR,4QAA4Q;YAC9Q,GAAG,EAAE,iFAAiF;SACvF;KACF;CACF,CAAC"}
+{"version":3,"file":"conventional-commits.js","sourceRoot":"","sources":["../../src/rules/conventional-commits.ts"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,MAAM,CAAC,MAAM,mBAAmB,GAAY;IAC1C,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EACT,qGAAqG;IACvG,KAAK,EAAE;QACL;YACE,IAAI,EAAE,gCAAgC;YACtC,WAAW,EACT,wEAAwE;YAC1E,SAAS,EACP,mQAAmQ;YACrQ,GAAG,EAAE,6HAA6H;SACnI;QACD;YACE,IAAI,EAAE,4BAA4B;YAClC,WAAW,EACT,kEAAkE;YACpE,SAAS,EACP,oSAAoS;YACtS,GAAG,EAAE,sIAAsI;SAC5I;QACD;YACE,IAAI,EAAE,4BAA4B;YAClC,WAAW,EAAE,4DAA4D;YACzE,SAAS,EACP,mIAAmI;YACrI,GAAG,EAAE,yEAAyE;SAC/E;QACD;YACE,IAAI,EAAE,uCAAuC;YAC7C,WAAW,EAAE,4DAA4D;YACzE,SAAS,EACP,gVAAgV;YAClV,GAAG,EAAE,kGAAkG;SACxG;QACD;YACE,IAAI,EAAE,8BAA8B;YACpC,WAAW,EACT,qEAAqE;YACvE,SAAS,EACP,4QAA4Q;YAC9Q,GAAG,EAAE,iFAAiF;SACvF;KACF;CACF,CAAC"}

package/dist/rules/established-libraries.js

@@ -6,13 +6,13 @@ export const establishedLibraries = {
         {
             name: 'established-libraries-first',
             description: 'Use a maintained, widely used open library with a small API before writing your own.',
-            convention: 'For a well-known problem, use an actively maintained, widely used open library with a small API before writing your own solution.',
+            statement: 'For a well-known problem, use an actively maintained, widely used open library with a small API before writing your own solution.',
             why: 'Such a library already handles the edge cases its many users have met, and its maintainers keep fixing it; bespoke code leaves all of that to you.',
         },
         {
             name: 'established-libraries-wrapped',
             description: 'Wrap the library behind the project’s own interface.',
-            convention: 'Wrap the library behind the project’s own interface, and have the rest of the code use that interface.',
+            statement: 'Wrap the library behind the project’s own interface, and have the rest of the code use that interface.',
             why: 'The project then learns one small API of its own, and replacing or upgrading the library changes one place.',
         },
     ],

package/dist/rules/established-libraries.js.map

@@ -1 +1 @@
-{"version":3,"file":"established-libraries.js","sourceRoot":"","sources":["../../src/rules/established-libraries.ts"],"names":[],"mappings":"AAEA,6FAA6F;AAC7F,MAAM,CAAC,MAAM,oBAAoB,GAAY;IAC3C,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EACT,mHAAmH;IACrH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,6BAA6B;YACnC,WAAW,EACT,sFAAsF;YACxF,UAAU,EACR,mIAAmI;YACrI,GAAG,EAAE,oJAAoJ;SAC1J;QACD;YACE,IAAI,EAAE,+BAA+B;YACrC,WAAW,EAAE,sDAAsD;YACnE,UAAU,EACR,wGAAwG;YAC1G,GAAG,EAAE,6GAA6G;SACnH;KACF;CACF,CAAC"}
+{"version":3,"file":"established-libraries.js","sourceRoot":"","sources":["../../src/rules/established-libraries.ts"],"names":[],"mappings":"AAEA,6FAA6F;AAC7F,MAAM,CAAC,MAAM,oBAAoB,GAAY;IAC3C,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EACT,mHAAmH;IACrH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,6BAA6B;YACnC,WAAW,EACT,sFAAsF;YACxF,SAAS,EACP,mIAAmI;YACrI,GAAG,EAAE,oJAAoJ;SAC1J;QACD;YACE,IAAI,EAAE,+BAA+B;YACrC,WAAW,EAAE,sDAAsD;YACnE,SAAS,EACP,wGAAwG;YAC1G,GAAG,EAAE,6GAA6G;SACnH;KACF;CACF,CAAC"}

package/dist/rules/gitflow.js

@@ -6,25 +6,25 @@ export const gitflow = {
         {
             name: 'gitflow-main-and-develop',
             description: 'main holds released states; develop is the integration line.',
-            convention: 'The repository keeps two long-lived branches. `main` holds production-ready state: every commit on it is a release, tagged with its version. `develop` holds the latest delivered development changes for the next release, and is where every feature is integrated.',
+            statement: 'The repository keeps two long-lived branches. `main` holds production-ready state: every commit on it is a release, tagged with its version. `develop` holds the latest delivered development changes for the next release, and is where every feature is integrated.',
             why: 'main then always shows exactly what is released, and develop always shows what the next release will be, so neither has to be reconstructed from history.',
         },
         {
             name: 'gitflow-feature-branches',
             description: 'Feature branches branch from develop and merge back into it with --no-ff.',
-            convention: 'Develop each feature on its own branch, branched from `develop` and named for the feature. When the feature is finished, merge it back into `develop` with `git merge --no-ff`, then delete the feature branch. Feature branches interact with `develop` only.',
+            statement: 'Develop each feature on its own branch, branched from `develop` and named for the feature. When the feature is finished, merge it back into `develop` with `git merge --no-ff`, then delete the feature branch. Feature branches interact with `develop` only.',
             why: '`--no-ff` always makes a merge commit, so the feature stays visible in history as one group of commits and can be reverted whole; work in progress stays off develop until it is finished.',
         },
         {
             name: 'gitflow-release-branches',
             description: 'Release branches branch from develop, then merge into main (tagged) and back into develop.',
-            convention: 'When `develop` holds what the next release should contain, branch `release-<version>` from it and give the release its version number there. The release branch takes only bug fixes, the version bump and release metadata. To finish it, merge it into `main` with `--no-ff`, tag that merge commit with the version, merge it back into `develop` with `--no-ff`, and delete it.',
+            statement: 'When `develop` holds what the next release should contain, branch `release-<version>` from it and give the release its version number there. The release branch takes only bug fixes, the version bump and release metadata. To finish it, merge it into `main` with `--no-ff`, tag that merge commit with the version, merge it back into `develop` with `--no-ff`, and delete it.',
             why: 'The release is prepared and stabilised on its own branch while develop goes on taking features for the release after it; merging back into develop keeps the release fixes there too.',
         },
         {
             name: 'gitflow-hotfix-branches',
             description: 'Hotfix branches branch from main, then merge into main (tagged) and into develop.',
-            convention: 'To fix a critical bug in a released version, branch `hotfix-<version>` from the tag on `main`, bump the patch version and fix the bug there. To finish it, merge it into `main` with `--no-ff` and tag that merge commit with the new version, then merge it into `develop` with `--no-ff` (or into the current release branch, where one exists), and delete it.',
+            statement: 'To fix a critical bug in a released version, branch `hotfix-<version>` from the tag on `main`, bump the patch version and fix the bug there. To finish it, merge it into `main` with `--no-ff` and tag that merge commit with the new version, then merge it into `develop` with `--no-ff` (or into the current release branch, where one exists), and delete it.',
             why: 'The fix ships from the released state without taking the unreleased work on develop, and merging it back keeps the fix in every later release.',
         },
     ],

package/dist/rules/gitflow.js.map

@@ -1 +1 @@
-{"version":3,"file":"gitflow.js","sourceRoot":"","sources":["../../src/rules/gitflow.ts"],"names":[],"mappings":"AAEA,wFAAwF;AACxF,MAAM,CAAC,MAAM,OAAO,GAAY;IAC9B,IAAI,EAAE,SAAS;IACf,WAAW,EACT,mHAAmH;IACrH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,8DAA8D;YAChE,UAAU,EACR,uQAAuQ;YACzQ,GAAG,EAAE,2JAA2J;SACjK;QACD;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,2EAA2E;YAC7E,UAAU,EACR,gQAAgQ;YAClQ,GAAG,EAAE,4LAA4L;SAClM;QACD;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,4FAA4F;YAC9F,UAAU,EACR,qXAAqX;YACvX,GAAG,EAAE,uLAAuL;SAC7L;QACD;YACE,IAAI,EAAE,yBAAyB;YAC/B,WAAW,EACT,mFAAmF;YACrF,UAAU,EACR,mWAAmW;YACrW,GAAG,EAAE,gJAAgJ;SACtJ;KACF;CACF,CAAC"}
+{"version":3,"file":"gitflow.js","sourceRoot":"","sources":["../../src/rules/gitflow.ts"],"names":[],"mappings":"AAEA,wFAAwF;AACxF,MAAM,CAAC,MAAM,OAAO,GAAY;IAC9B,IAAI,EAAE,SAAS;IACf,WAAW,EACT,mHAAmH;IACrH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,8DAA8D;YAChE,SAAS,EACP,uQAAuQ;YACzQ,GAAG,EAAE,2JAA2J;SACjK;QACD;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,2EAA2E;YAC7E,SAAS,EACP,gQAAgQ;YAClQ,GAAG,EAAE,4LAA4L;SAClM;QACD;YACE,IAAI,EAAE,0BAA0B;YAChC,WAAW,EACT,4FAA4F;YAC9F,SAAS,EACP,qXAAqX;YACvX,GAAG,EAAE,uLAAuL;SAC7L;QACD;YACE,IAAI,EAAE,yBAAyB;YAC/B,WAAW,EACT,mFAAmF;YACrF,SAAS,EACP,mWAAmW;YACrW,GAAG,EAAE,gJAAgJ;SACtJ;KACF;CACF,CAAC"}

package/dist/rules/green-field.js

@@ -6,13 +6,13 @@ export const greenField = {
         {
             name: 'green-field-declared-constraints',
             description: 'Existing code and docs constrain work only where explicitly declared.',
-            convention: 'Treat existing code, records and docs as constraints only where a constraint is explicitly declared; everywhere else, shape the work by what it is for.',
+            statement: 'Treat existing code, records and docs as constraints only where a constraint is explicitly declared; everywhere else, shape the work by what it is for.',
             why: 'What happens to exist is history, not requirement; reading it as a constraint carries its accidents into every new piece of work.',
         },
         {
             name: 'green-field-clean-cutover',
             description: 'Compatibility is a goal only where it is declared.',
-            convention: 'Make the change the work calls for and migrate every caller with it, removing what it makes obsolete; keep compatibility with earlier forms only where it is declared a goal.',
+            statement: 'Make the change the work calls for and migrate every caller with it, removing what it makes obsolete; keep compatibility with earlier forms only where it is declared a goal.',
             why: 'Each shim or alias kept by default is a second way to do one thing that every later reader must understand; a clean cutover leaves one.',
         },
     ],

package/dist/rules/green-field.js.map

@@ -1 +1 @@
-{"version":3,"file":"green-field.js","sourceRoot":"","sources":["../../src/rules/green-field.ts"],"names":[],"mappings":"AAEA,wFAAwF;AACxF,MAAM,CAAC,MAAM,UAAU,GAAY;IACjC,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,oHAAoH;IACtH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,kCAAkC;YACxC,WAAW,EACT,uEAAuE;YACzE,UAAU,EACR,yJAAyJ;YAC3J,GAAG,EAAE,mIAAmI;SACzI;QACD;YACE,IAAI,EAAE,2BAA2B;YACjC,WAAW,EAAE,oDAAoD;YACjE,UAAU,EACR,+KAA+K;YACjL,GAAG,EAAE,yIAAyI;SAC/I;KACF;CACF,CAAC"}
+{"version":3,"file":"green-field.js","sourceRoot":"","sources":["../../src/rules/green-field.ts"],"names":[],"mappings":"AAEA,wFAAwF;AACxF,MAAM,CAAC,MAAM,UAAU,GAAY;IACjC,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,oHAAoH;IACtH,KAAK,EAAE;QACL;YACE,IAAI,EAAE,kCAAkC;YACxC,WAAW,EACT,uEAAuE;YACzE,SAAS,EACP,yJAAyJ;YAC3J,GAAG,EAAE,mIAAmI;SACzI;QACD;YACE,IAAI,EAAE,2BAA2B;YACjC,WAAW,EAAE,oDAAoD;YACjE,SAAS,EACP,+KAA+K;YACjL,GAAG,EAAE,yIAAyI;SAC/I;KACF;CACF,CAAC"}

package/dist/rulesets.js

@@ -1,13 +1,15 @@
 // ─────────────────────────────────────────────────────────────────────────────
-// The corpus's rulesets: standard working conventions an install offers, each
+// The canon's rulesets: the named sets of rules an install offers, each taken
 // whole, rule by rule, or not at all.
 // ─────────────────────────────────────────────────────────────────────────────
+import { behaviourDrivenDevelopment } from './rules/behaviour-driven-development.js';
 import { commitDiscipline } from './rules/commit-discipline.js';
 import { conventionalCommits } from './rules/conventional-commits.js';
 import { establishedLibraries } from './rules/established-libraries.js';
 import { gitflow } from './rules/gitflow.js';
 import { greenField } from './rules/green-field.js';
 export const RULESETS = [
+    behaviourDrivenDevelopment,
     gitflow,
     conventionalCommits,
     commitDiscipline,

package/dist/rulesets.js.map

@@ -1 +1 @@
-{"version":3,"file":"rulesets.js","sourceRoot":"","sources":["../src/rulesets.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,8EAA8E;AAC9E,sCAAsC;AACtC,gFAAgF;AAGhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,MAAM,CAAC,MAAM,QAAQ,GAAuB;IAC1C,OAAO;IACP,mBAAmB;IACnB,gBAAgB;IAChB,oBAAoB;IACpB,UAAU;CACX,CAAC"}
+{"version":3,"file":"rulesets.js","sourceRoot":"","sources":["../src/rulesets.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,8EAA8E;AAC9E,sCAAsC;AACtC,gFAAgF;AAGhF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,MAAM,CAAC,MAAM,QAAQ,GAAuB;IAC1C,0BAA0B;IAC1B,OAAO;IACP,mBAAmB;IACnB,gBAAgB;IAChB,oBAAoB;IACpB,UAAU;CACX,CAAC"}

package/dist/skills/conceptualize/skill.js

@@ -1,22 +1,22 @@
 // COMPOSES NOTHING, and that is the repair.
 //
-// This cell used to declare `composition: () => [exemplify, signify, materialize]` and import those
+// This skill used to declare `composition: () => [exemplify, signify, materialize]` and import those
 // modules to do it. The thunk's only consumer is the trailing `Composed from …`
-// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-body.ts`), so each
 // import bought one sentence of provenance and cost a module-level cycle: the four
-// signification cells each claimed to be composed from the other three, and no one of
+// signification skills each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: these cells RESTATE each
-// other's signs in different registers (prose here, signature there). A citation
-// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
-// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// The relation those edges named is CITATION, not dependency: these skills RESTATE each
+// other's terms in different registers (prose here, signature there). A citation
+// belongs inside the block, at the term that borrows it (`@ <skill>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these skills
 // in whatever order the work wants.
 export const conceptualize = {
     name: 'conceptualize',
-    description: `use this skill to extract the concepts latent in a source — which are primitive, what each means, how each factors — deciding nothing about names or form; stage 1 of exemplify.`,
+    description: `Find the concepts a source holds before any is named — which are primitive, what each means, and which concepts each of the others is built from, so each is distinct and together they cover the source. Reach for it when a design, a document or a domain has to be broken into concepts before each gets its Cratylic name; it decides no term and no form.`,
     formalBlock: `sources             ≜ input material ⟨multi-modal · bears substrate-boundaries⟩
-concept-record      ≜ ⟨ gloss , anchor? , factorization? ⟩
+concept-record      ≜ ⟨ meaning , term? , factorization? ⟩
 resolve(sources)    ≜ ⋃ { content(s) | s ∈ sources }
 D                 ≜ { d | d a distinction drawn over resolve(sources) } ⟨finite⟩
 depalimpsest(d)     ≜ d ↾ live-strata
@@ -27,10 +27,10 @@ intent(c)           ≜ c
 ⊔ P                 ≜ cl(⋃ { intent(c) | c ∈ P })   ,  P ⊆ C
 prim(c)           ⇔ ∄ P ⊆ C \\ {c} : ⊔ P = intent(c)
 dfp(g)              ≜ densest-faithful-point(g)
-gloss(c)            ≜ dfp(intent(c))   ,  prim(c)
+meaning(c)          ≜ dfp(intent(c))   ,  prim(c)
 fac(m)            ≜ { P ⊆ C \\ {m} | ⊔ P = intent(m) ∧ ∄ Q ⊊ P : ⊔ Q = intent(m) }
 distillable(c)      ≜ prim(c) ∨ fac(c) ≠ ∅
-produce(sources)    ≜ { ( gloss(c), ⊥, ⊥ ) | c ∈ C }
+produce(sources)    ≜ { ( meaning(c), ⊥, ⊥ ) | c ∈ C }
 
 boundaries(sources) ∉ D
 cl(X)             ⊇ X

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/conceptualize/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,oGAAoG;AACpG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,uFAAuF;AACvF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,aAAa,GAAU;IAClC,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,kLAAkL;IAC/L,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;sBAwBqC;IACvC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/conceptualize/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,qGAAqG;AACrG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,uFAAuF;AACvF,+CAA+C;AAC/C,EAAE;AACF,wFAAwF;AACxF,iFAAiF;AACjF,sFAAsF;AACtF,uFAAuF;AACvF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,aAAa,GAAU;IAClC,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,iWAAiW;IAC9W,WAAW,EACT;;;;;;;;;;;;;;;;;;;;;;;;sBAwBqC;IACvC,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/elicit/skill.js

@@ -1,29 +1,29 @@
 // COMPOSES NOTHING, and that is the repair.
 //
-// This cell used to declare `composition: () => [probe, signify, conceptualize]` and import those
+// This skill used to declare `composition: () => [probe, signify, conceptualize]` and import those
 // modules to do it. The thunk's only consumer is the trailing `Composed from …`
-// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-body.ts`), so each
 // import bought one sentence of provenance and cost a module-level cycle: the four
-// signification cells each claimed to be composed from the other three, and no one of
+// signification skills each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: these cells RESTATE each
-// other's signs in different registers (prose here, signature there). A citation
-// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
-// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// The relation those edges named is CITATION, not dependency: these skills RESTATE each
+// other's terms in different registers (prose here, signature there). A citation
+// belongs inside the block, at the term that borrows it (`@ <skill>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these skills
 // in whatever order the work wants.
 export const elicit = {
     name: 'elicit',
-    description: `use this skill to elicit the operator's hidden intended concept — recover it by asking maximally-informative yes/no questions, each a distinction that bisects the live candidates by prior mass (binary-search / information-gain over the concept lattice), converging in the fewest questions; the active, query-driven counterpart to probe (which reads a signifier already given) — stop when one candidate survives or no question is worth its burden, then hand the recovered concept to signify to name.`,
+    description: `Recover the concept a person means but has not yet put into words, by yes-or-no questions that each split the meanings still possible as evenly as they can, stopping when one is left or no question is worth asking. Reach for it when what is wanted is unclear and asking beats guessing; the concept recovered then goes to signify for its term.`,
     formalBlock: `C        ≜ concept lattice
 D        ≜ distinction set
 c          ≜ a closed distinction-set ; c ⊆ D
 q ∈ c      ⇔ c draws the distinction q
 priors   ≜ structured understanding of a token before any definition
 μ          ≜ prior mass over candidates read off priors by conceptual fit ; μ : ℘(C) → [0,1] ; μ(C) = 1
-t          ≜ the operator's hidden target concept ; t ∈ C ; unobserved
+t          ≜ the product owner's hidden target concept ; t ∈ C ; unobserved
 candidates          ≜ the live candidate set ; candidates ⊆ C
-q          ≜ a query ; q ∈ D ; operator answers yes ∨ no
+q          ≜ a query ; q ∈ D ; product owner answers yes ∨ no
 θ          ≜ the burden threshold ; θ ∈ (0,1]
 
 Y(q)      ≜ { c ∈ candidates | q ∈ c }

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/elicit/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,kGAAkG;AAClG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,+CAA+C;AAC/C,EAAE;AACF,uFAAuF;AACvF,iFAAiF;AACjF,qFAAqF;AACrF,sFAAsF;AACtF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,ofAAof;IACjgB,WAAW,EAAE;;;;;;;;;;;;;;;;oGAgBwG;IACrH,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/elicit/skill.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,EAAE;AACF,mGAAmG;AACnG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,uFAAuF;AACvF,+CAA+C;AAC/C,EAAE;AACF,wFAAwF;AACxF,iFAAiF;AACjF,sFAAsF;AACtF,uFAAuF;AACvF,oCAAoC;AAEpC,MAAM,CAAC,MAAM,MAAM,GAAU;IAC3B,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,wVAAwV;IACrW,WAAW,EAAE;;;;;;;;;;;;;;;;oGAgBwG;IACrH,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/exemplify/skill.js

@@ -1,42 +1,40 @@
 import { primePrinciple } from '../../genus/prime-principle.js';
 // COMPOSES NOTHING, and that is the repair.
 //
-// This cell used to declare `composition: () => [conceptualize, signify, materialize]` and import those
+// This skill used to declare `composition: () => [conceptualize, signify, materialize]` and import those
 // modules to do it. The thunk's only consumer is the trailing `Composed from …`
-// line of the projected SKILL.md (`forge/src/core/exemplify/skill-cell.ts`), so each
+// line of the projected SKILL.md (`forge/src/core/exemplify/skill-body.ts`), so each
 // import bought one sentence of provenance and cost a module-level cycle: the four
-// signification cells each claimed to be composed from the other three, and no one of
+// signification skills each claimed to be composed from the other three, and no one of
 // them could be read, taken or deployed alone.
 //
-// The relation those edges named is CITATION, not dependency: these cells RESTATE each
-// other's signs in different registers (prose here, signature there). A citation
-// belongs inside the block, at the sign that borrows it (`@ <cell>`), where it needs
-// no import and cannot cycle. Composition is the caller's: an agent pipes these cells
+// The relation those edges named is CITATION, not dependency: these skills RESTATE each
+// other's terms in different registers (prose here, signature there). A citation
+// belongs inside the block, at the term that borrows it (`@ <skill>`), where it needs
+// no import and cannot cycle. Composition is the caller's: an agent pipes these skills
 // in whatever order the work wants.
-const FORMAL_BLOCK = `concept-record     ≜ ⟨ gloss , anchor? , factorization? ⟩
-sources            ≜ input material @ conceptualize ⟨the corpus D is drawn OVER, ¬ D itself⟩
+const FORMAL_BLOCK = `concept-record     ≜ ⟨ meaning , term? , factorization? ⟩
+sources            ≜ input material @ conceptualize ⟨the material D is drawn OVER, ¬ D itself⟩
 C                  ≜ concept lattice @ conceptualize
 produce            : sources → concept-record @ conceptualize
-name               : concept-record → concept-record @ signify ⟨a core name or value takes its σ* anchor · any other term keeps the industry's own⟩
+name               : concept-record → concept-record @ signify ⟨each concept takes its Cratylic name, the established term where its domain already names it⟩
 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, given f's signifiers + inline ≜ with its bounded context's name and subject, nothing of intent(f))
-body(k)            ≜ cell k's authored surface ⟨front-matter excluded⟩
+R_fresh(f)         ≜ a fresh model's reading of fragment f (zero project-K, given f's terms + inline ≜ with its bounded context's name and subject, nothing of intent(f))
+body(k)            ≜ piece 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
+K                  ≜ project-K, the warm knowledge (the project's own texts) a reader already holds
 minimal            @ signify
 conform            @ signify
-Cells              ≜ the authored cells of the corpus exemplified, self included
+Pieces             ≜ the authored pieces of the source 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⟩] }
+manifest           ≜ { source , exemplified_at , reader , routes[⟨fragment_digest, idea_meaning, home_slug, disposition, rank⟩] , delta[⟨fragment_digest, idea_meaning⟩] }
 
 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) ∧ (k ∈ core ⇒ coldpass(k))
-produce ↦ gloss ; name ↦ anchor ; realize ↦ factorization
-∀ k ∈ Cells : accept(k) defined
+freshpass(k) ⇔ R_fresh(body(k)) ≅ meaning(k) ∧ decode_warm(body(k) | K) ≅ R_fresh(body(k))
+valid(k)    ⇔ REC(k) ≽ k ∧ minimal(k) ∧ conform(k) ∧ freshpass(k)
+produce ↦ meaning ; name ↦ term ; realize ↦ factorization
+∀ k ∈ Pieces : accept(k) defined
 disposition ∈ { reuse, mint }
 ∀ c ∈ C : c ∈ routes ⊻ c ∈ delta
 accept(F(sources)) = F(sources) ⇒ manifest @ .manifests/<source>.json
@@ -48,7 +46,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, cold-decoding only the core agent dimension names and values; emits the R3 routing manifest that catches the dropped idea.`,
+    description: `Restate a body of context, an agent, a skill or a document, in Cratylic names — find its concepts, give each its term with its precising definition, and write it back built from them, keeping each piece only when its fresh reading gives the meaning intended and every idea of the source has a place. Reach for it when context written as freeform prose should carry its concepts by name, shorter and meaning nothing beyond what is intended.`,
     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,uFAAuF;AACvF,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"}
+{"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,yGAAyG;AACzG,gFAAgF;AAChF,qFAAqF;AACrF,mFAAmF;AACnF,uFAAuF;AACvF,+CAA+C;AAC/C,EAAE;AACF,wFAAwF;AACxF,iFAAiF;AACjF,sFAAsF;AACtF,uFAAuF;AACvF,oCAAoC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA8B2B,CAAC;AAEjD,MAAM,CAAC,MAAM,SAAS,GAAU;IAC9B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,ybAAyb;IACtc,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;IACrB,QAAQ,EAAE,cAAc;CACzB,CAAC"}

package/dist/skills/formalize/skill.js

@@ -3,13 +3,13 @@ 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, 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.`,
+    description: `State a process, a practice or a skill exactly — each concept by its term, with the laws that hold between them and no prose that explains, accepted only when the process can be rebuilt from the statement at least as faithfully as from the prose. Reach for it when a procedure must read the same to every model, its reading lacking nothing of the procedure and adding nothing to it.`,
     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 ⟨core agent dimension names and values @ signify · every other term the industry's own⟩
-β ≜ { s | s imported, its anchor cited once in adjacent notation }
+η : E ∪ O ⇀ symbols ⟨each entity and operation by its term @ signify⟩
+β ≜ { s | s imported, its term cited once in adjacent notation }
 ι ≜ { s | s resolved from invocation context }
 
 B ≜ formalize(prose) such that :
@@ -21,10 +21,10 @@ closed(B)   ⇔ symbols(B) ⊆ T ∪ Dfn ∪ β ∪ ι
 complete(B) ⇔ ∀ b ∈ behavior(prose) : ∃ line ∈ B : line ⊨ b
 ordered(B)  ⇔ ∀ s ∈ Dfn : definition(s) precedes use(s)
 self-sufficient(B) ⇔ closed(B) ∧ complete(B) ∧ ordered(B)
-gloss(B) ≜ prose of B beyond β ∪ ι ; gloss(B) ≠ ∅ ⇒ ¬complete(B)
+commentary(B) ≜ prose of B beyond β ∪ ι ; commentary(B) ≠ ∅ ⇒ ¬complete(B)
 ¬self-sufficient(B) ⇒ ⊥
 
-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⟩
+s ∉ T ⇒ extend T with s ; ¬ degrade the notation to a weaker one already in T ⟨llm-native · a block's notation needs no fresh reading⟩
 
 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,idAAid;IAC9d,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;2BAuB+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,gYAAgY;IAC7Y,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;2BAuB+B;IAC5C,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC;IAC3C,QAAQ,EAAE,cAAc;CACzB,CAAC"}