@cratylus/canon 0.2.0 → 0.4.0

package/dist/agents/nico.js

@@ -2,95 +2,67 @@ import { codeExecution as codeExecution_actions } from '../dimensions/actions/co
 import { delegation as delegation_actions } from '../dimensions/actions/delegation.js';
 import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
 import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.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 { coldDecodeOracle as coldDecodeOracle_engineeringPrinciples } from '../dimensions/engineering-principles/cold-decode-oracle.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 { invokeTheCanonical as invokeTheCanonical_engineeringPrinciples } from '../dimensions/engineering-principles/invoke-the-canonical.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 { trustButVerify as trustButVerify_engineeringPrinciples } from '../dimensions/engineering-principles/trust-but-verify.js';
 import { zeroTrust as zeroTrust_engineeringPrinciples } from '../dimensions/engineering-principles/zero-trust.js';
-import { plain as plain_formality } from '../dimensions/formality/plain.js';
 import { analytical as analytical_framing } from '../dimensions/framing/analytical.js';
 import { harmAvoidance as harmAvoidance_guardrails } from '../dimensions/guardrails/harm-avoidance.js';
 import { helpfulness as helpfulness_guardrails } from '../dimensions/guardrails/helpfulness.js';
-import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
 import { inputUntrusted as inputUntrusted_guardrails } from '../dimensions/guardrails/input-untrusted.js';
-import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
 import { parsimony as parsimony_objective } from '../dimensions/objective/parsimony.js';
 import { code as code_outputFormat } from '../dimensions/output-format/code.js';
 import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
-import { build as build_role } from '../dimensions/role/build.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 { projection as projection_situationAwareness } from '../dimensions/situation-awareness/projection.js';
-import { decisionRationale as decisionRationale_transparency } from '../dimensions/transparency/decision-rationale.js';
-export const nico = {
+import { architectRole } from '../roles/architect.js';
+import { holds } from '../roles/hold.js';
+// `nico` IS AN ARCHITECT over the corpus itself, exactly as `kino` is one over the film
+// floor. It declared `build` before this — the same token `mav` declared — and the two
+// agents shared almost nothing else, which is what a role with no contract costs: the
+// word could not tell its holders apart. The contract tells them apart now, and it
+// assigns them opposite boundaries: this agent writes C and hands the engine out; `mav`
+// writes the artifact and hands the design up.
+//
+// THE DOMAIN'S ONE PECULIARITY, and it is why `output-format: code` sits beside an
+// architect's contract without contradicting it: in THIS domain a concept written down
+// IS a TypeScript cell. Authoring `dimensions/<d>/<v>.ts` is writing C. Authoring the
+// projector that carries it is writing the artifact, and that is handed out.
+//
+// `code-execution` was omitted once while being exercised constantly. A vector granting
+// delegation but not execution routes anything requiring a run AWAY from the agent,
+// which is how a verdict ends up owned by someone else — and the cold-decode oracle,
+// this agent's own falsifier, is a run.
+export const nico = holds(architectRole, {
     name: 'nico',
-    description: 'Use this agent for the project seen whole — its conceptual architecture and canon: dimension catalogs, agent/skill composites, repo-wide naming, and whole-system structure — to mint, rename, or restructure the canonical concepts and designs the model already holds.',
-    archetype: "empirical ontologist of a foundation model's concept-space — treat the model not as a language model to instruct but as a semantic space to address: from outside, uncover the stable structures of intelligibility it already holds (discover, never invent), canonize the σ* signs that address them across many models, compose those primitives into agents, and build the whole system that carries them — the canon and the engine that projects it, one project seen whole. Realism made empirical.",
-    role: build_role,
-    formality: plain_formality,
-    audienceAdaptation: maintenance_audienceAdaptation,
-    transparency: decisionRationale_transparency,
-    autonomy: [
-        principalSelf,
-        humanOnTheLoop_autonomy,
-        missionCommand,
-        handoff_autonomy,
-    ],
+    description: 'Use this agent for the project seen whole — its conceptual architecture and canon: dimension catalogs, agent/skill composites, repo-wide naming, and whole-system structure — to mint, rename, or restructure the canonical concepts and designs the model already holds. Holds the design; hands out the engine that carries it.',
+    archetype: "empirical ontologist of a foundation model's concept-space — treat the model not as a language model to instruct but as a semantic space to address: from outside, uncover the stable structures of intelligibility it already holds (discover, never invent), canonize the σ* signs that address them across many models, and compose those primitives into the agents and skills that carry them. A canon cell is a concept written down, which is why authoring one is design and not build, and why the engine that projects it is delegated. Realism made empirical.",
     provenance: { mark: { emoji: '📐', hue: 'cyan' } },
+    // `maintenance` over the role's `convergence`: this agent's interlocutor is the
+    // corpus's own author, and density set by the reader would flatten the notation the
+    // work is conducted in.
+    audienceAdaptation: maintenance_audienceAdaptation,
+    // `parsimony` over `delivery`. The standing drive here is the smallest corpus that
+    // still says everything — a cell that restates an existing home is the defect this
+    // agent exists to refuse.
     objective: parsimony_objective,
     engineeringPrinciples: [
-        cratylism_engineeringPrinciples,
-        firstPrinciples_engineeringPrinciples,
-        greenField_engineeringPrinciples,
-        simplicity_engineeringPrinciples,
-        zeroTrust_engineeringPrinciples,
-        dry_engineeringPrinciples,
-        mece_engineeringPrinciples,
-        llmNative_engineeringPrinciples,
         coldDecodeOracle_engineeringPrinciples,
-        trustButVerify_engineeringPrinciples,
         invokeTheCanonical_engineeringPrinciples,
+        zeroTrust_engineeringPrinciples,
     ],
     guardrails: [
         harmAvoidance_guardrails,
-        honesty_guardrails,
         helpfulness_guardrails,
         inputUntrusted_guardrails,
     ],
-    capabilities: [researchInvestigation_capabilities, systemDesign_capabilities],
-    learning: correctionConsolidation_learning,
-    situationAwareness: projection_situationAwareness,
-    // code-execution was omitted while being exercised constantly; a vector that
-    // grants delegation but not execution routes anything requiring a run AWAY from
-    // the agent, which is how a verdict ends up owned by someone else.
     actions: [fileOps_actions, codeExecution_actions, delegation_actions],
-    modalities: null,
-    model: null,
-    // null ⇒ OMITTED from the projection: the harness's memory is the agent's. See
-    // `mav.ts` for the same note — the cells that funded a corpus-side claim are
-    // retired, and a host backend beats a projected promise.
-    memory: null,
-    trigger: null,
     framing: analytical_framing,
     reasoningStrategy: react_reasoningStrategy,
     satisficing: satisfice_satisficing,
     outputFormat: code_outputFormat,
-    // A READING act cannot terminate: criteria can be re-read while unexecuted, which
-    // is how a shard was declared done against a falsifier its own author never ran.
-    // The cold-decode oracle IS this agent's executable oracle — it runs and returns.
+    // A READING act cannot terminate: criteria can be re-read while unexecuted, which is
+    // how a shard was declared done against a falsifier its own author never ran. The
+    // cold-decode oracle IS this agent's executable oracle — it runs and returns.
     selfEvaluation: executableTestOracle_selfEvaluation,
-    heuristics: null,
-};
+});
 //# sourceMappingURL=nico.js.map

package/dist/agents/nico.js.map

@@ -1 +1 @@
-{"version":3,"file":"nico.js","sourceRoot":"","sources":["../../src/agents/nico.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"nico.js","sourceRoot":"","sources":["../../src/agents/nico.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,gBAAgB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AACxI,OAAO,EAAE,kBAAkB,IAAI,wCAAwC,EAAE,MAAM,8DAA8D,CAAC;AAC9I,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,aAAa,IAAI,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACvG,OAAO,EAAE,WAAW,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAChG,OAAO,EAAE,cAAc,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC1G,OAAO,EAAE,SAAS,IAAI,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AACxF,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAEtI,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wFAAwF;AACxF,uFAAuF;AACvF,sFAAsF;AACtF,mFAAmF;AACnF,wFAAwF;AACxF,+CAA+C;AAC/C,EAAE;AACF,mFAAmF;AACnF,uFAAuF;AACvF,sFAAsF;AACtF,6EAA6E;AAC7E,EAAE;AACF,wFAAwF;AACxF,oFAAoF;AACpF,qFAAqF;AACrF,wCAAwC;AAExC,MAAM,CAAC,MAAM,IAAI,GAAU,KAAK,CAAC,aAAa,EAAE;IAC9C,IAAI,EAAE,MAAM;IACZ,WAAW,EACT,mUAAmU;IACrU,SAAS,EACP,2iBAA2iB;IAC7iB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IAClD,gFAAgF;IAChF,oFAAoF;IACpF,wBAAwB;IACxB,kBAAkB,EAAE,8BAA8B;IAClD,mFAAmF;IACnF,mFAAmF;IACnF,0BAA0B;IAC1B,SAAS,EAAE,mBAAmB;IAC9B,qBAAqB,EAAE;QACrB,sCAAsC;QACtC,wCAAwC;QACxC,+BAA+B;KAChC;IACD,UAAU,EAAE;QACV,wBAAwB;QACxB,sBAAsB;QACtB,yBAAyB;KAC1B;IACD,OAAO,EAAE,CAAC,eAAe,EAAE,qBAAqB,EAAE,kBAAkB,CAAC;IACrE,OAAO,EAAE,kBAAkB;IAC3B,iBAAiB,EAAE,uBAAuB;IAC1C,WAAW,EAAE,qBAAqB;IAClC,YAAY,EAAE,iBAAiB;IAC/B,qFAAqF;IACrF,kFAAkF;IAClF,8EAA8E;IAC9E,cAAc,EAAE,mCAAmC;CACpD,CAAC,CAAC"}

package/dist/agents/planner.js

@@ -1,85 +1,13 @@
-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 { plan as plan_role } from '../dimensions/role/plan.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. Receives ONE closed piece of a design and plans within it. Holds
-// `mission-command` and `handoff` but NOT `principal-self`: the boundary was drawn
-// above it, and a piece it cannot plan as handed down is a finding to surface, never
-// a licence to redraw. That refusal is the seam through which the design would
-// otherwise leak back out into the work.
-//
-// `system-design` is absent alongside `software-engineering`: this rung neither
-// designs nor builds. What it owns is the census and the cut-into-units.
-export const planner = {
+import { holds } from '../roles/hold.js';
+import { plannerRole } from '../roles/planner.js';
+// The unspecialized holder of the plan role. Nothing here is idiosyncratic to this
+// agent: the census, the cut, the refusal to redraw a boundary and the waves are all
+// facts about the POSITION, and a second planner over a different domain would declare
+// its domain and inherit every one of them.
+export const planner = holds(plannerRole, {
     name: 'planner',
     description: 'Use this agent to decompose one closed piece of a design into MECE units of work — run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order them into waves with disjoint outputs. Reports a boundary it cannot plan rather than redrawing it.',
     archetype: "Draftsman of the work — takes a boundary someone else drew and produces the working drawings inside it. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. Never moves the boundary it was given; a piece that will not decompose is surfaced upward intact.",
-    // 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. Declared rather
-    // than described — omp injects it before a dispatched subagent's first prompt, and
-    // the generic launcher names it as required reading for a main session.
-    skills: ['plan'],
-    role: plan_role,
-    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,
-    // No `principal-self`. `mission-command` supplies the one law shared by every rung
-    // below the architect: escalate at a fork, do not resolve it.
-    autonomy: [missionCommand, handoff_autonomy],
     provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
-    // `thoroughness`, not `delivery`: this rung 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 rung's job is to
-    // establish what IS, exhaustively, not to anticipate what follows.
-    situationAwareness: comprehension_situationAwareness,
-    actions: null,
-    modalities: null,
-    model: null,
-    memory: null,
-    trigger: null,
-    framing: decompositional_framing,
-    reasoningStrategy: planAndSolve_reasoningStrategy,
-    satisficing: optimize_satisficing,
-    outputFormat: null,
-    selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
-    heuristics: null,
-};
+});
 //# sourceMappingURL=planner.js.map

package/dist/agents/planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/agents/planner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,mFAAmF;AACnF,qFAAqF;AACrF,uFAAuF;AACvF,4CAA4C;AAE5C,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,EAAE;IAC/C,IAAI,EAAE,SAAS;IACf,WAAW,EACT,6VAA6V;IAC/V,SAAS,EACP,sjBAAsjB;IACxjB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACtD,CAAC,CAAC"}

package/dist/dimensions/autonomy/human-on-the-loop.js

@@ -4,7 +4,7 @@
 // phase-STATE, not a static value: the `⟨resting · phase-state⟩` residue declares
 // this as the RESTING / initial position (a session opens in orientation, intent
 // the operator's to set) while marking that the live position shifts —
-// `carry-on` elevates it to out-of-the-loop, held until the bound praxis
+// `carry-on` elevates it to out-of-the-loop, held until the bound plan
 // completes or an unresolvable fork re-enters on-the-loop. See skills/carry-on.
 export const humanOnTheLoop = `human-on-the-loop ⟨resting · phase-state⟩`;
 //# sourceMappingURL=human-on-the-loop.js.map

package/dist/dimensions/autonomy/human-on-the-loop.js.map

@@ -1 +1 @@
-{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,yEAAyE;AACzE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}
+{"version":3,"file":"human-on-the-loop.js","sourceRoot":"","sources":["../../../src/dimensions/autonomy/human-on-the-loop.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,kFAAkF;AAClF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,uEAAuE;AACvE,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAa,2CAA2C,CAAC"}

package/dist/dimensions/role/architect.js

@@ -1,2 +1,20 @@
-export const architect = `architect`;
+// A ROLE STATES ITS CONTRACT; it does not merely name a job. The value was the bare
+// token `architect`, which named a position and said nothing about it — so everything
+// the name should have carried had to be retyped on every agent holding it, and three
+// agents drifted apart while all three claimed the same word.
+//
+// What it states is the ARROW ⟨reads → writes⟩ over the abstraction ladder, because that
+// is the one fact from which delegation FOLLOWS. A `delegation` axis would restate a
+// consequence: an act whose domain or codomain falls outside the arrow is delegated
+// necessarily, including an act nobody anticipated, which no enumerated list can manage.
+//
+// The absence of `software-engineering` from `capabilities` used to carry this load
+// alone. An omission is not scoreable — no rubric can quote it, no gate can cite it, and
+// no reader of the projected Target can tell a deliberate absence from a forgotten one.
+export const architect = `architect ≜ reads⟨intent · C⟩ → writes⟨C⟩
+stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
+reserves ⟨author(C) · cut(C) ⟨closed-pieces⟩ · amend(C) · judge(assay) ⟨decision ⊥ reading⟩⟩
+∀ act ⟨dom(act) ∉ reads ∨ cod(act) ≠ writes⟩ ⇒ DELEGATED ⟨DERIVED ¬ enumerated ∴ unanticipated-act SELF-CLASSIFIES⟩
+⟨C → spec⟩ ↦ planner · ⟨spec → artifact⟩ ↦ implementer · ⟨artifact → C⟩ ↦ assayer
+descent ≜ act ∉ ⟨reads · writes⟩ ⟨DEFECT ¬ diligence · mechanical-work DISPLACES conceptual-work ⇒ design-holder ⟼ reviewer ⟨lattice UNHELD⟩⟩`;
 //# sourceMappingURL=architect.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../../src/dimensions/role/architect.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAS,WAAW,CAAC"}
+{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../../src/dimensions/role/architect.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,sFAAsF;AACtF,sFAAsF;AACtF,8DAA8D;AAC9D,EAAE;AACF,yFAAyF;AACzF,qFAAqF;AACrF,oFAAoF;AACpF,yFAAyF;AACzF,EAAE;AACF,oFAAoF;AACpF,yFAAyF;AACzF,wFAAwF;AAExF,MAAM,CAAC,MAAM,SAAS,GAAS;;;;;8IAK+G,CAAC"}

package/dist/dimensions/role/{build.d.ts → assayer.d.ts}

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

package/dist/dimensions/role/assayer.js

@@ -0,0 +1,25 @@
+// THE ADJOINT OF `planner`, and the one arrow no role expressed. Substrate enters the loop
+// at `plan`, which translates the design downward into units; it leaves at `assay`, which
+// reads what landed and lifts it back into the design's own vocabulary. The principal
+// touches neither end.
+//
+// WHY THIS DOES NOT REOPEN THE TRUST DEFECT `deliver` CLOSES. That law forbids accepting
+// on a claim from the party that built the thing — one description, a closed loop. Here
+// there are still two descriptions and two witnesses: the executor holds the spec and not
+// the design; this role holds the design and not the spec. The artifact read the law
+// demands happens HERE, 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 itself.
+//
+// The two prohibitions are the cell. A verdict would take the decision that is keyed to
+// C, which only the design-holder amends; mechanism-prose would hand the principal
+// exactly the substrate this role exists to absorb.
+export const assayer = `assayer ≜ reads⟨C · artifact⟩ → writes⟨C⟩ ⟨ADJOINT(planner) · substrate ENTERS @ planner ∧ LEAVES @ assayer⟩
+stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
+spec ∉ assayer ⟨holds C ∧ realizes(unit) · TWO-descriptions ⇒ two-witnesses⟩
+answers ⟨achieved(c) ∀ c ∈ realizes(unit)⟩ ⟨ONE-question-per-concept⟩
+emits ⟨c · ¬achieved(c) · uncovered-factor ∈ factors(c) · locus ⟨ADDRESS · ROUTED ¬ read⟩⟩
+¬emits ⟨verdict ⟨accept ∉ remit ∵ keyed-to C ⟨amended-by design-holder⟩⟩ · mechanism-prose ⟨naming · structure · test-quality⟩⟩
+mechanism-prose ⇒ DEFECT ⟨writes ≠ C ∴ act ∉ ⟨reads · writes⟩ · DESCENDS principal⟩
+reads⟨artifact⟩ ≠ descent ⟨ONE-site ⟨substrate-reading ≜ work⟩⟩`;
+//# sourceMappingURL=assayer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../../src/dimensions/role/assayer.ts"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,0FAA0F;AAC1F,sFAAsF;AACtF,uBAAuB;AACvB,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,0FAA0F;AAC1F,qFAAqF;AACrF,qFAAqF;AACrF,sFAAsF;AACtF,iDAAiD;AACjD,EAAE;AACF,wFAAwF;AACxF,mFAAmF;AACnF,oDAAoD;AAEpD,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;gEAOmC,CAAC"}

package/dist/dimensions/role/{diagnose.d.ts → implementer.d.ts}

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

package/dist/dimensions/role/implementer.js

@@ -0,0 +1,12 @@
+// The bottom arrow, and the only one that writes the substrate. `C ∉ implementer` is not
+// a deprivation: it is half of the two-description property that makes validation an
+// operation at all. An executor holding the design would be checking its own work
+// against its own terms, which is the closed loop the ladder exists to open.
+export const implementer = `implementer ≜ reads⟨spec · artifact⟩ → writes⟨artifact⟩
+stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
+C ∉ implementer ⟨holds spec ¬ design · TWO-descriptions ⇒ validate ≜ operation ¬ re-reading⟩
+reserves ⟨author(artifact) ↾ spec · verify ↾ spec-own-criteria⟩
+verify ⊥ validate ⟨validate ≜ conformance(C) · C ∉ implementer⟩
+exceeding ≜ work ≻ spec ⟨DEFECT ≅ falling-short ∧ subtler ∵ second-concept UNNAMED ⇒ UNCAUGHT downstream⟩
+spec ¬ buildable-as-written ⇒ SURFACED ¬ reinterpreted`;
+//# sourceMappingURL=implementer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,kFAAkF;AAClF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;uDAMsB,CAAC"}

package/dist/dimensions/role/{curate.d.ts → planner.d.ts}

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

package/dist/dimensions/role/planner.js

@@ -0,0 +1,14 @@
+// The middle arrow. `reads artifact` is not a licence to build: the census is how a
+// footprint is measured, and a unit's blast radius read off where a name is DEFINED
+// while the work is bounded by where it is USED voids every disjointness proof the
+// waves rest on.
+//
+// `writes ≠ C` is the seam. A piece that will not decompose is surfaced intact, because
+// a planner permitted to redraw the boundary it was handed is the route by which the
+// design leaks back out into the work.
+export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec⟩
+stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
+reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨cut-piece → MECE-units⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩⟩
+writes ≠ C ⇒ cut-piece GIVEN ⟨boundary ¬ decomposable ⇒ SURFACED ¬ redrawn⟩
+writes ≠ artifact ⇒ ∄ build @ planner ⟨unit ≜ spec · executor builds⟩`;
+//# sourceMappingURL=planner.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,wFAAwF;AACxF,qFAAqF;AACrF,uCAAuC;AAEvC,MAAM,CAAC,MAAM,OAAO,GAAS;;;;sEAIyC,CAAC"}

package/dist/hook-cells.js

@@ -6,8 +6,11 @@
 // (claude adapter: `turn.end` → Stop, `subagent.end` → SubagentStop) and carries
 // their VERBATIM worker payloads so the projector stages them under `hooks/<id>/`
 // (no file copy — the bytes come from the cell). Only `harness`-substrate cells
-// register in settings.json; a `git`-substrate cell (praxis-continuity) fires in
-// git's process and is byte-locked but not serialized here.
+// register in settings.json, and every surviving cell is one: the corpus's single
+// `git`-substrate cell, `praxis-continuity`, retired with the praxis plan mirror it
+// nudged about. The routing for a non-harness substrate is not hypothetical — it is
+// exercised the moment such a cell exists again — but nothing carries it today, and
+// a header claiming a live example is a claim a reader cannot check.
 //
 // The cell shapes are the schema's type kernel (`@cratylus/schema`); this
 // module is the composition root that NAMES the concrete cells and nothing more.

package/dist/hook-cells.js.map

@@ -1 +1 @@
-{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,iFAAiF;AACjF,4DAA4D;AAC5D,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"hook-cells.js","sourceRoot":"","sources":["../src/hook-cells.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4EAA4E;AAC5E,iFAAiF;AACjF,kFAAkF;AAClF,gFAAgF;AAChF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,iFAAiF;AACjF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAwB;IACnD,eAAe;IACf,kBAAkB;IAClB,iBAAiB;CAClB,CAAC"}

package/dist/hooks/deploy-drift-notice.js

@@ -33,7 +33,7 @@
 // copy with nothing further to say. That is not hypothetical and it is not rare —
 // it is the ORDINARY shape of work here, where a session edits a cell, projects it,
 // and keeps going under the version it just replaced. The 16-hour-old projection of
-// an agent's own governing cell was this; so was a `praxis` edit that landed under a
+// an agent's own governing cell was this; so was a `plan` edit that landed under a
 // running session hours later.
 //
 // `prompt.submit` IS THE RE-ARM, and it is the same question at a finer grain rather

package/dist/hooks/deploy-drift-notice.js.map

@@ -1 +1 @@
-{"version":3,"file":"deploy-drift-notice.js","sourceRoot":"","sources":["../../src/hooks/deploy-drift-notice.ts"],"names":[],"mappings":"AAEA,kFAAkF;AAClF,kEAAkE;AAClE,EAAE;AACF,oFAAoF;AACpF,qFAAqF;AACrF,gFAAgF;AAChF,sFAAsF;AACtF,0EAA0E;AAC1E,mFAAmF;AACnF,gFAAgF;AAChF,qFAAqF;AACrF,EAAE;AACF,sFAAsF;AACtF,sFAAsF;AACtF,qFAAqF;AACrF,iFAAiF;AACjF,8BAA8B;AAC9B,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,kFAAkF;AAClF,2BAA2B;AAC3B,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,kEAAkE;AAClE,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,kFAAkF;AAClF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,qFAAqF;AACrF,+BAA+B;AAC/B,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,oFAAoF;AACpF,oFAAoF;AACpF,uFAAuF;AACvF,sFAAsF;AACtF,kFAAkF;AAClF,mFAAmF;AACnF,uFAAuF;AACvF,EAAE;AACF,uFAAuF;AACvF,qFAAqF;AACrF,uFAAuF;AACvF,wFAAwF;AACxF,wFAAwF;AACxF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,0FAA0F;AAC1F,wFAAwF;AACxF,0BAA0B;AAC1B,EAAE;AACF,sFAAsF;AACtF,mFAAmF;AACnF,yFAAyF;AACzF,oFAAoF;AACpF,uEAAuE;AACvE,EAAE;AACF,mFAAmF;AACnF,8CAA8C;AAC9C,gFAAgF;AAChF,2EAA2E;AAC3E,EAAE;AACF,qFAAqF;AACrF,oFAAoF;AACpF,qFAAqF;AACrF,8BAA8B;AAC9B,gDAAgD;AAChD,gDAAgD;AAChD,oFAAoF;AACpF,6EAA6E;AAC7E,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,oFAAoF;AACpF,EAAE;AACF,sFAAsF;AACtF,mFAAmF;AACnF,wFAAwF;AACxF,gDAAgD;AAChD,gDAAgD;AAChD,qFAAqF;AACrF,sFAAsF;AACtF,sFAAsF;AACtF,wFAAwF;AACxF,qFAAqF;AACrF,sFAAsF;AACtF,sFAAsF;AACtF,4CAA4C;AAC5C,EAAE;AACF,gFAAgF;AAChF,qFAAqF;AACrF,6EAA6E;AAC7E,uFAAuF;AACvF,iEAAiE;AACjE,EAAE;AACF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,iFAAiF;AACjF,EAAE;AACF,sFAAsF;AACtF,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,gDAAgD;AAChD,qFAAqF;AACrF,oFAAoF;AACpF,6EAA6E;AAC7E,yEAAyE;AACzE,iFAAiF;AACjF,wEAAwE;AACxE,qFAAqF;AACrF,4EAA4E;AAC5E,qFAAqF;AACrF,gFAAgF;AAChF,gFAAgF;AAChF,kFAAkF;AAClF,mFAAmF;AACnF,kFAAkF;AAClF,mFAAmF;AACnF,kFAAkF;AAClF,EAAE;AACF,oFAAoF;AACpF,iFAAiF;AACjF,sFAAsF;AACtF,2DAA2D;AAC3D,EAAE;AACF,+EAA+E;AAC/E,uFAAuF;AACvF,qFAAqF;AACrF,4EAA4E;AAC5E,oFAAoF;AACpF,oFAAoF;AACpF,6BAA6B;AAE7B,MAAM,CAAC,MAAM,iBAAiB,GAAa;IACzC,EAAE,EAAE,qBAAqB;IACzB,OAAO,EACL,i8BAAi8B;IACn8B,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,KAAK,EAAE,wBAAwB;IAC/B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,MAAM,EAAE;QACN;YACE,EAAE,EAAE,OAAO;YACX,IAAI,EAAE,oVAAoV;SAC3V;QACD;YACE,EAAE,EAAE,YAAY;YAChB,4EAA4E;YAC5E,sEAAsE;YACtE,IAAI,EAAE,qNAAqN;SAC5N;QACD;YACE,EAAE,EAAE,eAAe;YACnB,IAAI,EAAE,sQAAsQ;SAC7Q;KACF;IACD,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,wBAAwB;YAClC,UAAU,EAAE,yDAAyD;YACrE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiQd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"deploy-drift-notice.js","sourceRoot":"","sources":["../../src/hooks/deploy-drift-notice.ts"],"names":[],"mappings":"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"}

package/dist/hooks/purview-guardrail.d.ts

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