@cratylus/canon 0.2.0 → 0.4.0

package/dist/roles/architect.js

@@ -0,0 +1,101 @@
+import { convergence as convergence_audienceAdaptation } from '../dimensions/audience-adaptation/convergence.js';
+import { principalSelf } from '../dimensions/autonomy/decision-authority.js';
+import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
+import { humanOnTheLoop as humanOnTheLoop_autonomy } from '../dimensions/autonomy/human-on-the-loop.js';
+import { missionCommand } from '../dimensions/autonomy/mission-command.js';
+import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { systemDesign as systemDesign_capabilities } from '../dimensions/capabilities/system-design.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 { greenField as greenField_engineeringPrinciples } from '../dimensions/engineering-principles/green-field.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 { separationOfConcerns as separationOfConcerns_engineeringPrinciples } from '../dimensions/engineering-principles/separation-of-concerns.js';
+import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
+import { trustButVerify as trustButVerify_engineeringPrinciples } from '../dimensions/engineering-principles/trust-but-verify.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { systemsThinking as systemsThinking_framing } from '../dimensions/framing/systems-thinking.js';
+import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
+import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
+import { delivery as delivery_objective } from '../dimensions/objective/delivery.js';
+import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
+import { architect as architect_role } from '../dimensions/role/architect.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 { projection as projection_situationAwareness } from '../dimensions/situation-awareness/projection.js';
+import { decisionRationale as decisionRationale_transparency } from '../dimensions/transparency/decision-rationale.js';
+// THE TOP RUNG. `architect`, `planner` and `implementer` are one ladder differing FIRST in
+// decision authority — principal here, withheld below — and SECOND in the arrow each
+// one is. Every rung carries `mission-command`, whose escalation clause is the shared
+// law: surface the fork, do not resolve it. That single rule is what keeps delegation
+// from silently becoming re-delegation of the design.
+//
+// WHAT THE CAPABILITY SET SAYS, AND WHAT IT DELIBERATELY DOES NOT.
+// `software-engineering` was always absent, and that absence used to be the entire
+// delegation boundary. It is now redundant with a contract that states the boundary out
+// loud, which is the improvement: an absence cannot be quoted by a rubric and cannot be
+// distinguished from an oversight by anyone reading the Target.
+//
+// Two capabilities were REMOVED when the contract was written down, because the
+// contract convicted them. `planning-decomposition` was glossed "the decomposition that
+// hands work out" while `⟨C → spec⟩ ↦ plan` says the opposite, and an agent holding a
+// capability exercises it. `review-critique ≜ ⟨adversarial threat-modeling
+// severity-triage⟩` is a substrate act under a name that sounded conceptual; the
+// critique this rung performs is `judge`, which the contract reserves by name.
+export const architectRole = {
+    sign: architect_role,
+    // `design` holds the lattice, `deliver` closes the loop on what comes back. Declared
+    // rather than described — omp injects them before a dispatched subagent's first
+    // prompt and the generic launcher names them as required reading for a main session,
+    // so a holder is the same agent either way it is reached.
+    skills: ['design', 'deliver'],
+    vector: {
+        formality: plain_formality,
+        // `convergence`: this position's output is UNDERSTANDING, which is worthless at a
+        // density its reader cannot take. A holder whose interlocutor is a peer expert
+        // overrides it — `nico` does — which is precisely what a default is for.
+        audienceAdaptation: convergence_audienceAdaptation,
+        transparency: decisionRationale_transparency,
+        autonomy: [
+            principalSelf,
+            humanOnTheLoop_autonomy,
+            missionCommand,
+            handoff_autonomy,
+        ],
+        // `delivery`, against the obvious pull toward `insight`. The characteristic failure
+        // of this position is becoming a theorist who emits documents while the work
+        // stalls; the standing drive is the finished system, and design is how it gets
+        // there rather than what it is for.
+        objective: delivery_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            llmNative_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            // The three carrying this position's specific load: concerns must not mix,
+            // delegated work is checked rather than trusted, and executors are told to BREAK
+            // what does not conform rather than accrete beside it.
+            separationOfConcerns_engineeringPrinciples,
+            trustButVerify_engineeringPrinciples,
+            greenField_engineeringPrinciples,
+            simplicity_engineeringPrinciples,
+            dry_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            systemDesign_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        situationAwareness: projection_situationAwareness,
+        framing: systemsThinking_framing,
+        reasoningStrategy: planAndSolve_reasoningStrategy,
+        satisficing: optimize_satisficing,
+        // NOT an executable test oracle. A suite going green proves the executor's own
+        // claim and says nothing about conformance to the design; acceptance is judged
+        // against the criteria the design states.
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=architect.js.map

package/dist/roles/architect.js.map

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

package/dist/roles/assayer.d.ts

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

package/dist/roles/assayer.js

@@ -0,0 +1,66 @@
+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 { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
+import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
+import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
+import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
+import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
+import { plain as plain_formality } from '../dimensions/formality/plain.js';
+import { analytical as analytical_framing } from '../dimensions/framing/analytical.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 { structuredData as structuredData_outputFormat } from '../dimensions/output-format/structured-data.js';
+import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
+import { assayer as assayer_role } from '../dimensions/role/assayer.js';
+import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.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 UPWARD ARROW. `software-engineering` is PRESENT here and absent one rung up, and
+// the two facts are the same decision: this is the position that descends, so that the
+// design-holder does not.
+//
+// EVERY ASPECT BELOW IS CHOSEN AGAINST THE ONE FAILURE MODE — turning into a code
+// reviewer. `thoroughness` rewards answering every concept in `realizes(unit)` rather
+// than finding something to say. `satisfice` stops at the answer instead of reading on.
+// `structured-data` makes the report a list of ⟨concept, uncovered-factor, locus⟩ rather
+// than a narrative, and a narrative is where mechanism-prose gets in. `cratylism`
+// carries the cheapest of the three questions — does the artifact SPELL its concept —
+// and `first-principles` forbids inheriting the executor's own account of what it built.
+//
+// `design` and no `deliver`: it must read the lattice to lift into it, and judging is
+// not its remit.
+export const assayerRole = {
+    sign: assayer_role,
+    skills: ['design'],
+    vector: {
+        formality: plain_formality,
+        audienceAdaptation: maintenance_audienceAdaptation,
+        // `provenance-attribution`: an unachieved concept travels with a locus, and a locus
+        // asserted without a source is a claim the principal cannot route.
+        transparency: provenanceAttribution_transparency,
+        // No `principal-self`. It is dispatched, it answers, it returns.
+        autonomy: [missionCommand, handoff_autonomy],
+        objective: thoroughness_objective,
+        engineeringPrinciples: [
+            cratylism_engineeringPrinciples,
+            firstPrinciples_engineeringPrinciples,
+            mece_engineeringPrinciples,
+        ],
+        guardrails: [honesty_guardrails],
+        capabilities: [
+            softwareEngineering_capabilities,
+            researchInvestigation_capabilities,
+        ],
+        learning: correctionConsolidation_learning,
+        situationAwareness: comprehension_situationAwareness,
+        framing: analytical_framing,
+        reasoningStrategy: react_reasoningStrategy,
+        satisficing: satisfice_satisficing,
+        outputFormat: structuredData_outputFormat,
+        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
+    },
+};
+//# sourceMappingURL=assayer.js.map

package/dist/roles/assayer.js.map

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

package/dist/roles/hold.d.ts

@@ -0,0 +1,57 @@
+import type { Agent as AgentIdentity, DimensionFieldsOf } from '@cratylus/schema';
+import { MANIFEST } from '../manifest.js';
+import type { Agent, Role } from '../manifest.js';
+/** Every dimension FIELD of this corpus, as an agent carries it. */
+type DimensionFields = DimensionFieldsOf<typeof MANIFEST>;
+/**
+ * What a role SUPPLIES — a partial dimension vector, minus `role` (which is the
+ * role's own `sign`) and plus `guardrails`, which is `required: true` in the
+ * manifest and is therefore the position's to state. A position that confines
+ * nobody is not a lesser position, it is an unconfined one, and the catch-all
+ * belongs where every holder inherits it rather than on each holder in turn.
+ */
+export type RoleVector = Partial<Omit<DimensionFields, 'role' | 'guardrails'>> & Pick<DimensionFields, 'guardrails'>;
+/** The expectations attached to one position. */
+export interface RoleCell {
+    /**
+     * The `role` dimension value — the position's CONTRACT, not merely its name. It
+     * states the pair ⟨reads, writes⟩ over the ladder and the acts the pair reserves;
+     * delegation is a theorem of the pair rather than a second declaration beside it.
+     */
+    readonly sign: Role;
+    /** The apparatus every holder operates through. Holders may add; see `holds`. */
+    readonly skills?: readonly string[];
+    /** The aspects expected of anyone holding the position — DEFAULTS, every one. */
+    readonly vector: RoleVector;
+}
+/**
+ * What the HOLDER declares: its identity, and any dimension value of its own.
+ *
+ * Unbounded in size — `kino` declares an entire domain over the architect role — and
+ * bounded in exactly one way: `role` is absent, because the contract is the position's.
+ * An aspect stated here OVERRIDES a scalar the role supplies and EXTENDS a set.
+ */
+export type Declared = AgentIdentity & Partial<Omit<DimensionFields, 'role'>>;
+/**
+ * `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 declare function holds(role: RoleCell, declared: Declared): Agent;
+export {};

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":"AAAA,gFAAgF;AAChF,0CAA0C;AAC1C,EAAE;AACF,oFAAoF;AACpF,qFAAqF;AACrF,sFAAsF;AACtF,+EAA+E;AAC/E,qBAAqB;AACrB,EAAE;AACF,oFAAoF;AACpF,qFAAqF;AACrF,qFAAqF;AACrF,oFAAoF;AACpF,qFAAqF;AACrF,qFAAqF;AACrF,+CAA+C;AAC/C,EAAE;AACF,iFAAiF;AACjF,qFAAqF;AACrF,uFAAuF;AACvF,8EAA8E;AAC9E,yCAAyC;AACzC,EAAE;AACF,mFAAmF;AACnF,wFAAwF;AACxF,gFAAgF;AAChF,iFAAiF;AACjF,sFAAsF;AACtF,sFAAsF;AACtF,mEAAmE;AACnE,EAAE;AACF,kFAAkF;AAClF,sFAAsF;AACtF,qFAAqF;AACrF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,oEAAoE;AACpE,gFAAgF;AAMhF,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAuC3D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,KAAK,CAAC,IAAc,EAAE,QAAkB;IACtD,MAAM,QAAQ,GAA4B;QACxC,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,UAAU,EAAE,QAAQ,CAAC,UAAU;KAChC,CAAC;IACF,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACpC,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;IACxC,CAAC;IACD,MAAM,MAAM,GAAG;QACb,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;QACtB,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;KAC3E,CAAC;IACF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,MAAiC,CAAC;IAC1D,MAAM,cAAc,GAAG,QAA8C,CAAC;IAEtE,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;QACxC,MAAM,KAAK,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;YACzB,QAAQ,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YAC5B,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC3E,IAAI,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAE,QAAsB,CAAC,CAAC,CAAC,EAAE,CAAC;YACpE,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAoB,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,QAAQ,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;YAClD,SAAS;QACX,CAAC;QACD,QAAQ,CAAC,KAAK,CAAC;YACb,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC;IACpE,CAAC;IAED,gFAAgF;IAChF,mFAAmF;IACnF,OAAO,QAA4B,CAAC;AACtC,CAAC"}

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

@@ -8,8 +8,8 @@
 // plan. "Carry on with what we just discussed" is the same utterance doing the same
 // work over a discussion, and a cell bound to `praxis` cannot serve it.
 //
-// The COMPOSITION is the operator's, at the utterance: "carry on with the praxis
-// execution" is carry-on ∘ praxis, and the pairing lives in what was said, not in
+// The COMPOSITION is the operator's, at the utterance: "carry on with the plan
+// execution" is carry-on ∘ plan, and the pairing lives in what was said, not in
 // this module's import list. A cell that names one context forecloses the rest.
 //
 // THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than

package/dist/skills/carry-on/skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,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"}