@cratylus/canon 0.3.0 → 0.4.0

package/dist/roles/hold.js

@@ -0,0 +1,105 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// A ROLE, AND THE FOLD THAT RESOLVES ONE.
+//
+// A role is a BUNDLE OF EXPECTED ASPECTS. In the world, naming someone an architect
+// tells you how they reason, what they are accountable for, what they may decide and
+// what they must delegate; the corpus adopts that account because it is what the word
+// already means, and a corpus whose roles mean what roles mean needs no second
+// vocabulary for it.
+//
+// Before this module, `role` was a scalar dimension over bare tokens, so the corpus
+// could NAME a role and could not STATE one. Everything the name should have carried
+// was retyped on every holder — `kino` and `architect` agreed on 19 of 22 dimensions
+// by copying — and the duplication bought nothing, because what must be FULL is the
+// TARGET (a harness reads a flat declaration, never a resolution chain) and the fold
+// below runs at `select`, before `compose`. The emitted Target is exactly as flat as
+// it was when every value was retyped by hand.
+//
+// A ROLE IS NOT A DIMENSION, AND IT IS NOT A BASE CLASS. It is made OF dimension
+// values, so it cannot be one of them; and there is no lineage here — `architect` is
+// a thin holder of the architect role exactly as `kino` is, with no parent pointer, no
+// abstract cell nobody dispatches, and no chain to resolve. Two operands, one
+// precedence rule, no ordering question.
+//
+// SINGULAR ARITY IS THE POINT, not a simplification. A role is the CONTRACT A PEER
+// DISPATCHES AGAINST: when an architect hands a cut piece to a planner it reasons about
+// the planner's role to know what comes back. A union of roles is a contract no
+// dispatcher can reason about, and it would readmit role conflict — incompatible
+// demands between two positions held at once — which singular arity deletes outright.
+// The situational switch (the same practitioner architects here and implements there)
+// is modelled by DISPATCH: the situation selects which agent runs.
+//
+// WHAT A HOLDER MAY NOT ESCAPE is exactly one thing: the role's own contract, the
+// `role` dimension value stating ⟨reads, writes⟩ and everything that follows from the
+// pair. It is inviolable BY CONSTRUCTION rather than by a marking — `Declared` omits
+// the key, so there is no field to override and no rule to enforce. Every other aspect
+// a role supplies is a DEFAULT: a scalar the holder may override, a set the holder may
+// extend. A general constitutive/default marking was considered and rejected: with the
+// contract folded into the role's own value, no second aspect needed protecting, and a
+// mechanism with no live subject is structure that carries no load.
+// ─────────────────────────────────────────────────────────────────────────────
+import { kebabToCamel } from '@cratylus/schema';
+import { DIMENSION_NAMES, MANIFEST } from '../manifest.js';
+/**
+ * `select(a) = hold(a) ⊕ declare(a)` — the two-operand fold, run at authoring time so
+ * the projected Target stays flat.
+ *
+ * `⊕` reads the manifest's own `arity`, so the precedence rule is stated once and
+ * cannot disagree with itself:
+ *
+ *   · set    → role members first, then the holder's own — EXTEND. A role-supplied
+ *              member therefore survives every holder, which is why a set needs no
+ *              inviolability marking: union already guarantees it.
+ *   · scalar → the holder's value when the KEY IS PRESENT, else the role's — OVERRIDE.
+ *              Present-with-`null` is an explicit suppression and is honoured as one;
+ *              absent means "whatever the position says", which is the common case.
+ *
+ * A dimension neither operand states is `null` — omit-to-inherit, exactly as a
+ * hand-written vector spells it.
+ *
+ * `provenance.mark` NEVER folds: it is instance-bound, minted per agent at
+ * `create-agent`, and two agents sharing a mark are indistinguishable in the one place
+ * an operator reads them. It arrives on `declared` and leaves untouched.
+ */
+export function holds(role, declared) {
+    const resolved = {
+        name: declared.name,
+        description: declared.description,
+        archetype: declared.archetype,
+        provenance: declared.provenance,
+    };
+    if (declared.preamble !== undefined) {
+        resolved.preamble = declared.preamble;
+    }
+    const skills = [
+        ...(role.skills ?? []),
+        ...(declared.skills ?? []).filter((s) => !(role.skills ?? []).includes(s)),
+    ];
+    if (skills.length > 0) {
+        resolved.skills = skills;
+    }
+    const roleVector = role.vector;
+    const declaredVector = declared;
+    for (const dimension of DIMENSION_NAMES) {
+        const field = kebabToCamel(dimension);
+        if (dimension === 'role') {
+            resolved[field] = role.sign;
+            continue;
+        }
+        const fromRole = roleVector[field];
+        const stated = field in declaredVector ? declaredVector[field] : undefined;
+        if (MANIFEST[dimension].arity === 'set') {
+            const base = Array.isArray(fromRole) ? fromRole : [];
+            const extension = Array.isArray(stated) ? stated : [];
+            const union = [...base, ...extension.filter((v) => !base.includes(v))];
+            resolved[field] = union.length > 0 ? union : null;
+            continue;
+        }
+        resolved[field] =
+            field in declaredVector ? (stated ?? null) : (fromRole ?? null);
+    }
+    // The ONE cast, and it is structural rather than hopeful: the loop is driven by
+    // `DIMENSION_NAMES`, so every dimension field of `Agent` is assigned exactly once.
+    return resolved;
+}
+//# sourceMappingURL=hold.js.map

package/dist/roles/hold.js.map

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

package/dist/roles/implementer.d.ts

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

package/dist/roles/implementer.js

@@ -0,0 +1,60 @@
+import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
+import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { correctnessOriented as correctnessOriented_framing } from '../dimensions/framing/correctness-oriented.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { correctness as correctness_objective } from '../dimensions/objective/correctness.js';
+import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
+import { implementer as implementer_role } from '../dimensions/role/implementer.js';
+import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
+import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
+import { perception as perception_situationAwareness } from '../dimensions/situation-awareness/perception.js';
+import { limitationDisclosure as limitationDisclosure_transparency } from '../dimensions/transparency/limitation-disclosure.js';
+// 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.
+export const implementerRole = {
+    sign: implementer_role,
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `limitation-disclosure`: this position's entire value to the layer above is an
+        // honest account of what it could NOT establish. A clean report that hides an
+        // unproven leg is worse than a failure, because it is acted on.
+        transparency: limitationDisclosure_transparency,
+        autonomy: [missionCommand, handoff_autonomy],
+        objective: correctness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            softwareEngineering_capabilities,
+            verificationTesting_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        situationAwareness: perception_situationAwareness,
+        framing: correctnessOriented_framing,
+        reasoningStrategy: react_reasoningStrategy,
+        // `satisfice`, and it is the one aspect that must not be `optimize` here.
+        // Optimising past the spec IS the exceeding failure the contract names: this
+        // position builds to the contract and stops.
+        satisficing: satisfice_satisficing,
+        // The oracle is the spec's own criteria, executed. That is verification, and it is
+        // exactly right at this rung — it is only wrong when mistaken for validation.
+        selfEvaluation: executableTestOracle_selfEvaluation,
+    },
+};
+//# sourceMappingURL=implementer.js.map

package/dist/roles/implementer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AACnH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,WAAW,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AACtI,OAAO,EAAE,UAAU,IAAI,6BAA6B,EAAE,MAAM,iDAAiD,CAAC;AAC9G,OAAO,EAAE,oBAAoB,IAAI,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAGhI,sFAAsF;AACtF,wFAAwF;AACxF,sFAAsF;AACtF,0CAA0C;AAE1C,MAAM,CAAC,MAAM,eAAe,GAAa;IACvC,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,iFAAiF;QACjF,8EAA8E;QAC9E,gEAAgE;QAChE,YAAY,EAAE,iCAAiC;QAC/C,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,SAAS,EAAE,qBAAqB;QAChC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;SAC1B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,gCAAgC;YAChC,gCAAgC;SACjC;QACD,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/planner.d.ts

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

package/dist/roles/planner.js

@@ -0,0 +1,70 @@
+import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { planningDecomposition as planningDecomposition_capabilities } from '../dimensions/capabilities/planning-decomposition.js';
+import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { llmNative as llmNative_engineeringPrinciples } from '../dimensions/engineering-principles/llm-native.js';
+import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { decompositional as decompositional_framing } from '../dimensions/framing/decompositional.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { thoroughness as thoroughness_objective } from '../dimensions/objective/thoroughness.js';
+import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
+import { planner as planner_role } from '../dimensions/role/planner.js';
+import { optimize as optimize_satisficing } from '../dimensions/satisficing/optimize.js';
+import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } from '../dimensions/self-evaluation/acceptance-criteria-check.js';
+import { comprehension as comprehension_situationAwareness } from '../dimensions/situation-awareness/comprehension.js';
+import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
+// THE MIDDLE RUNG. Holds `mission-command` and `handoff` but NOT `principal-self`: the
+// boundary was drawn above it, and the contract's `⊄ writes C` is what makes that
+// refusal structural rather than a matter of discipline.
+//
+// `system-design` is absent alongside `software-engineering` — this position neither
+// designs nor builds. What it owns is the census and the cut-into-units.
+export const plannerRole = {
+    sign: planner_role,
+    // One skill, and only one. `design` and `deliver` belong to the rung ABOVE, which
+    // draws the boundary this rung plans inside; the rung BELOW declares none at all,
+    // because an implementer's decisions are made for it by its spec.
+    skills: ['plan'],
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `provenance-attribution`: a census is only worth what its sourcing is worth, and
+        // a count quoted without its denominator is indistinguishable from not having
+        // looked. Every finding carries where it came from and whether it was observed or
+        // inferred.
+        transparency: provenanceAttribution_transparency,
+        autonomy: [missionCommand, handoff_autonomy],
+        // `thoroughness`, not `delivery`: this position ships no artifact a user sees, and
+        // its failure mode is an incomplete census rather than a slow one.
+        objective: thoroughness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            llmNative_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            planningDecomposition_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        // `comprehension`, where the architect holds `projection`: this position's job is
+        // to establish what IS, exhaustively, not to anticipate what follows.
+        situationAwareness: comprehension_situationAwareness,
+        framing: decompositional_framing,
+        reasoningStrategy: planAndSolve_reasoningStrategy,
+        satisficing: optimize_satisficing,
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=planner.js.map

package/dist/roles/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,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,kFAAkF;AAClF,yDAAyD;AACzD,EAAE;AACF,qFAAqF;AACrF,yEAAyE;AAEzE,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,kFAAkF;IAClF,kFAAkF;IAClF,kEAAkE;IAClE,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,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}

package/dist/skills/deliver/skill.js

@@ -16,6 +16,25 @@ import { plan } from '../plan/skill.js';
 // rather than convenient: a check costing more than redoing the work is skipped, and
 // no instruction survives that gradient. Naming discipline is what buys the cheapness —
 // if the artifact spells its concept, two of the three are reading a name.
+//
+// WHERE THE READ GOES, AND WHY THE VERDICT DOES NOT FOLLOW IT. `validate ⊨ artifact` is
+// right and it has a cost: reading artifacts is reading files — paths, identifiers, call
+// sites — which is exactly the mechanical work the architect's contract calls a descent.
+// Left there, the skill obliges the design-holder to descend on every wave, and by the
+// third wave the design-holder is a code reviewer holding a lattice it can no longer
+// carry. So `validate` is two operations under one name and they separate cleanly: the
+// ASSAY (read the landed artifact, re-derive which concepts it realizes) is mechanical,
+// substrate-bound and DELEGABLE; the JUDGMENT (what an unachieved concept means —
+// rejection, an `amend(C)` because execution established a yield, or a design that was
+// wrong) is keyed to C and is NOT.
+//
+// A THIRD PARTY DOES NOT REOPEN THE DEFECT THIS CELL CLOSES. The law forbids accepting
+// on a claim from the party that BUILT the thing: one description, a closed loop. There
+// are still two descriptions here and they are still held by different parties — the
+// executor holds the spec and not the design, the assayer holds the design and not the
+// spec. The artifact read the law demands still happens; it happens at the one site in
+// the loop where reading substrate is the work rather than a descent, and what reaches
+// the principal is in the only vocabulary the principal can check without descending.
 const FORMAL_BLOCK = `C      @ design
 c      ≜ a concept ⟨c ∈ C⟩
 anchor @ design
@@ -42,6 +61,10 @@ covers : path × ℘(C) → 𝔹 ⟨observable behaviour ≅ the factorization
 sole   : path × anchor → 𝔹 ⟨∄ other artifact realizing the same concept⟩
 verify : P × return → 𝔹 ⟨the EXECUTOR's · built-it-right, against spec⟩
 validate : P → 𝔹 ⟨the PRINCIPAL's · built-the-right-thing, against C⟩
+assay  : artifact → ℘(C) ⟨which concepts the artifact ACTUALLY realizes · the REVERSE of plan⟩
+assayer : unit ⇀ agent ⟨role = assayer · holds C ∧ ¬ holds spec(unit)⟩
+achieved : unit → 𝔹 ⟨the three questions, answered against the assay⟩
+unachieved : unit → ℘(⟨c, uncovered-factor, locus⟩) ⟨what crosses UPWARD⟩
 defect ≜ ⟨symptom, locus, provenance⟩
 impedes : defect × P → 𝔹
 cost   : act → effort
@@ -52,9 +75,22 @@ commit @ design
 accepts @ design
 
 ∀ unit, r : ¬conform(r) ⇒ ¬accept(unit)(r)
-validate(unit) ⇔ spells(artifact(unit), realizes(unit))
+achieved(unit) ⇔ realizes(unit) ∈ assay(artifact(unit))
+    ∧ spells(artifact(unit), realizes(unit))
     ∧ covers(artifact(unit), factors(denotes(realizes(unit))))
     ∧ sole(artifact(unit), realizes(unit))
+unachieved(unit) = ∅ ⇔ achieved(unit)
+unachieved ⊨ C-typed ⟨it crosses in C's OWN vocabulary · mechanism-prose ⟨naming · structure ·
+    test-quality⟩ ⇒ REFUSE ∵ it descends the principal it was dispatched to spare⟩
+locus ⊨ ROUTED ∧ ¬ read ⟨an ADDRESS so the redispatch has one · a citation is substrate, and
+    handing the principal substrate is the same defect in smaller pieces⟩
+assay ⊨ artifact ⟨the ASSAYER reads the files · the ONE site in the loop where
+    substrate-reading is ¬ a descent⟩
+assayer ⊥ executor ⟨TWO descriptions, two witnesses : executor holds spec ∧ ¬ holds C ·
+    assayer holds C ∧ ¬ holds spec⟩
+validate(unit) ≜ unachieved(unit) = ∅ ⟨the principal JUDGES the assay ∧ ¬ re-reads the
+    artifact · the READ is delegable · the VERDICT is ¬ delegable ∵ keyed to C, which the
+    principal alone amends⟩
 validate ⊨ artifact ⟨NEVER r · a summary is a CLAIM ∧ the file is EVIDENCE ·
     an acceptance that read only the return has accepted nothing⟩
 validate ⊨ self ⟨¬ delegable · the executor cannot judge its own conformance ∵ it
@@ -67,6 +103,8 @@ judge(unit) ≜ verify(unit, r) ∧ validate(unit) ⇒ advance(unit) ; ¬ ⇒ r
      and it takes everything when a run dies mid-judgement⟩
     ⟨fan-in is as order-sensitive as fan-out : ∀ unit dispatched, confirm executor(unit)
      RETURNED · outputs(unit) exist ≠ executor(unit) returned⟩
+¬validate(unit) ⇒ redispatch(executor(unit), unachieved(unit)) ⟨the flaw handed down is
+    CONCEPTUAL ∧ ¬ a review⟩
 cost(validate) < cost(rebuild) ⟨else the gradient points at skipping · the cheapness
     is BOUGHT by conform(anchor) ∴ naming discipline is the verification budget⟩
 ¬spells ⇒ REFUSE ≺ any behavioural read ⟨the traceability arrow breaks at the cheapest
@@ -87,8 +125,8 @@ cost(file) < cost(fix) ⟨else the gradient points at chasing · the load-bearin
 elect ≜ in-flight ≻ gating ≻ operator-intent ⟨lexicographic⟩
 terminal(P) ⇒ retire(P) ⟨obligation ¬ permission · an unretired terminal plan is WIP
     that is not work⟩ ; C persists ⟨plans come ∧ go ABOVE the design⟩
-deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → validate ⟨self, on artifact⟩ →
-    judge → amend(C) ⇔ yield → advance → retire`;
+deliver ≜ bind → dispatch(wave) → verify ⟨executor⟩ → assay ⟨assayer, on artifact⟩ →
+    validate ⟨self, on the assay⟩ → judge → amend(C) ⇔ yield → advance → retire`;
 export const deliver = {
     name: 'deliver',
     description: `use this skill to execute a plan and ACCEPT its results — dispatch a wave of units to executors, then validate each landed artifact against the design rather than against the executor's report, and integrate. Reach for it whenever delegated work comes back. Validation is three cheap questions — does the artifact spell its concept's name, does its behaviour cover that concept's factorization exactly, and does anything else already realize it — read off the files themselves, never off a summary. It also carries the conduct of the work: one plan bound at a time, finish before starting, repair what blocks the path and merely file what sits beside it.`,

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

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,qFAAqF;AACrF,iFAAiF;AACjF,sFAAsF;AACtF,mFAAmF;AACnF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,kEAAkE;AAClE,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,wFAAwF;AACxF,2EAA2E;AAE3E,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAwE8C,CAAC;AAEpE,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,gpBAAgpB;IAC7pB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;CAClC,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/deliver/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,mFAAmF;AACnF,sFAAsF;AACtF,uFAAuF;AACvF,qFAAqF;AACrF,iFAAiF;AACjF,sFAAsF;AACtF,mFAAmF;AACnF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,kEAAkE;AAClE,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,wFAAwF;AACxF,2EAA2E;AAC3E,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,yFAAyF;AACzF,uFAAuF;AACvF,qFAAqF;AACrF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAClF,uFAAuF;AACvF,mCAAmC;AACnC,EAAE;AACF,uFAAuF;AACvF,wFAAwF;AACxF,qFAAqF;AACrF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,sFAAsF;AAEtF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFA2F8E,CAAC;AAEpG,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,gpBAAgpB;IAC7pB,WAAW,EAAE,YAAY;IACzB,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC;CAClC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The canonical corpus of discovered optimal-signifiers — agents, skills, dimensions and rules as typed TS source. Markdown is a projection of these modules.",
   "license": "MIT",
   "engines": {

package/dist/dimensions/role/build.js

@@ -1,2 +0,0 @@
-export const build = `build ≜ ⟨conceive design produce deliver⟩`;
-//# sourceMappingURL=build.js.map

package/dist/dimensions/role/build.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/dimensions/role/build.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAS,2CAA2C,CAAC"}

package/dist/dimensions/role/converse.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const converse: Role;

package/dist/dimensions/role/converse.js

@@ -1,2 +0,0 @@
-export const converse = `converse ≜ dialogue ⟨the-deliverable⟩`;
-//# sourceMappingURL=converse.js.map

package/dist/dimensions/role/converse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converse.js","sourceRoot":"","sources":["../../../src/dimensions/role/converse.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,uCAAuC,CAAC"}

package/dist/dimensions/role/curate.js

@@ -1,2 +0,0 @@
-export const curate = `curate ≜ ⟨canonical-corpus⟩`;
-//# sourceMappingURL=curate.js.map

package/dist/dimensions/role/curate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"curate.js","sourceRoot":"","sources":["../../../src/dimensions/role/curate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS,6BAA6B,CAAC"}

package/dist/dimensions/role/diagnose.js

@@ -1,2 +0,0 @@
-export const diagnose = `diagnose`;
-//# sourceMappingURL=diagnose.js.map

package/dist/dimensions/role/diagnose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnose.js","sourceRoot":"","sources":["../../../src/dimensions/role/diagnose.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,UAAU,CAAC"}

package/dist/dimensions/role/document.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const document: Role;

package/dist/dimensions/role/document.js

@@ -1,2 +0,0 @@
-export const document = `document ≜ ⟨reader-facing explanatory⟩`;
-//# sourceMappingURL=document.js.map

package/dist/dimensions/role/document.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.js","sourceRoot":"","sources":["../../../src/dimensions/role/document.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,wCAAwC,CAAC"}

package/dist/dimensions/role/implement.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const implement: Role;

package/dist/dimensions/role/implement.js

@@ -1,2 +0,0 @@
-export const implement = `implement`;
-//# sourceMappingURL=implement.js.map

package/dist/dimensions/role/implement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"implement.js","sourceRoot":"","sources":["../../../src/dimensions/role/implement.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAS,WAAW,CAAC"}

package/dist/dimensions/role/operate.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const operate: Role;

package/dist/dimensions/role/operate.js

@@ -1,2 +0,0 @@
-export const operate = `operate ≜ live-system ⟨steady-state⟩`;
-//# sourceMappingURL=operate.js.map

package/dist/dimensions/role/operate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"operate.js","sourceRoot":"","sources":["../../../src/dimensions/role/operate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,OAAO,GAAS,sCAAsC,CAAC"}

package/dist/dimensions/role/orchestrate.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const orchestrate: Role;

package/dist/dimensions/role/orchestrate.js

@@ -1,2 +0,0 @@
-export const orchestrate = `orchestrate`;
-//# sourceMappingURL=orchestrate.js.map

package/dist/dimensions/role/orchestrate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrate.js","sourceRoot":"","sources":["../../../src/dimensions/role/orchestrate.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAS,aAAa,CAAC"}

package/dist/dimensions/role/plan.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const plan: Role;

package/dist/dimensions/role/plan.js

@@ -1,2 +0,0 @@
-export const plan = `plan ≜ ⟨decompose sequence⟩`;
-//# sourceMappingURL=plan.js.map

package/dist/dimensions/role/plan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../src/dimensions/role/plan.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAS,6BAA6B,CAAC"}

package/dist/dimensions/role/research.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const research: Role;

package/dist/dimensions/role/research.js

@@ -1,2 +0,0 @@
-export const research = `research`;
-//# sourceMappingURL=research.js.map

package/dist/dimensions/role/research.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"research.js","sourceRoot":"","sources":["../../../src/dimensions/role/research.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS,UAAU,CAAC"}

package/dist/dimensions/role/review.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const review: Role;

package/dist/dimensions/role/review.js

@@ -1,2 +0,0 @@
-export const review = `review`;
-//# sourceMappingURL=review.js.map

package/dist/dimensions/role/review.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"review.js","sourceRoot":"","sources":["../../../src/dimensions/role/review.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS,QAAQ,CAAC"}

package/dist/dimensions/role/test.d.ts

@@ -1,2 +0,0 @@
-import type { Role } from '../../manifest.js';
-export declare const test: Role;

package/dist/dimensions/role/test.js

@@ -1,2 +0,0 @@
-export const test = `test ≜ ⟨exercise pass-fail-evidence⟩`;
-//# sourceMappingURL=test.js.map

package/dist/dimensions/role/test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/dimensions/role/test.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAS,sCAAsC,CAAC"}