@cratylus/canon 0.13.0 → 0.13.1

package/README.md

@@ -9,17 +9,19 @@ therefore not a prompt. It is a **dimension-selection vector** over signified va
 markdown a harness reads is a projection of these modules.
 
 Canon is harness-agnostic **and** runtime-agnostic: it says what an agent _is_ and what a skill
-_means_, never how either is carried.
+_means_, never how either is carried. What every package is for is
+[ARCHITECTURE.md](../../ARCHITECTURE.md)'s; installing the corpus on a machine, and choosing among
+its practices, is [the `cratylus` README](../cli/README.md)'s. This README is for the author of a
+corpus, or of a plugin that extends this one.
 
-## Install
+## Using it
 
 ```bash
 npm install cratylus @cratylus/canon
 ```
 
 The package's whole public surface is its default export — canon as an agent-plugin. A consumer
-`extends` it from a `cratylus.config.ts` and projects it with the `cratylus` command, whose
-[README](../cli/README.md) documents each command:
+`extends` it from a `cratylus.config.ts` and projects it with the `cratylus` command:
 
 ```ts
 import { defineConfig } from 'cratylus';
@@ -37,49 +39,60 @@ resolved by a registry, and every part of a composite is traceable to its one ho
 
 ## What the plugin carries
 
-| field       | what it is                                                                          |
-| ----------- | ----------------------------------------------------------------------------------- |
-| `manifest`  | **which dimensions exist** — 22, across the `Persona` / `Constitution` axes         |
-| `fragments` | the dimension value modules, filed one per dimension directory                      |
-| `agents`    | the agent vectors                                                                   |
-| `skills`    | the skill cells — each a self-sufficient formal block plus the siblings it composes |
-| `hooks`     | the hook cells, each carrying its verbatim worker payload                           |
-| `practices` | **which ways of working exist** — each an installable choice, declared as data      |
-| `plumbing`  | what every practice is installed with and none is offered as                        |
+| field       | what it is                                                                                           |
+| ----------- | ---------------------------------------------------------------------------------------------------- |
+| `manifest`  | **which dimensions exist** — 22, across the `'Persona'` and `'Constitution'` axes                    |
+| `events`    | **which lifecycle events exist** — the corpus's harness-agnostic event vocabulary                    |
+| `fragments` | the dimension value modules, filed one per dimension directory                                       |
+| `agents`    | the agent vectors                                                                                    |
+| `skills`    | the skill cells — each a self-sufficient formal block plus the siblings it composes                  |
+| `hooks`     | the hook cells, each carrying its verbatim worker payload                                            |
+| `practices` | **which ways of working exist** — each an installable choice, declared as data in `src/practices.ts` |
+| `plumbing`  | what every practice is installed with and none is offered as, declared beside them                   |
 
 Canon owns the catalog because a dimension is **constitutive**: declaring one makes it part of that
 corpus's agent design. The manifest rides the plugin rather than living in the projector, so a
 consumer can extend this design — or add a dimension to it — without editing the tool that renders
-it. The shapes those cells are authored against are [`@cratylus/schema`](../schema/README.md)'s.
-
-A **practice** is a way of working this corpus offers as one installable choice: the agents, skills
-and hooks that carry it, installed together. `src/practices.ts` declares four — `cdd` (concept-driven
-development, the one a fresh install preselects), `corpus-authoring`, `film-production` and `carry-on` —
-each with a one-line description written for a consumer, and the plumbing, the event tap and the
-session-wide drift notice, that every practice is installed with and none is offered as. A practice
-is closed under skill composition and agent dispatch: it lists the agents its agents dispatch to, and
-the dispatch relation is data (`Agent.dispatches`, copied by the `holds` fold from the role cell's
-`dispatches`), so projection refuses a chosen set that places a dispatcher without the roles it
-dispatches. A guard is listed nowhere: it is registered when a rendered agent composes what it binds.
+it. The shapes those cells are authored against, and `defineAgentPlugin` that declares the plugin,
+are [`@cratylus/schema`](../schema/README.md)'s.
+
+## The agents
+
+The plugin carries eight agents. `architect`, `planner`, `implementer`, `assayer` and `integrator`
+are the generic holders of their roles: each is named for the role it holds, the role cell
+(`src/roles/`) states the description, archetype and mark that holder carries along with the
+dimension values every holder is expected to select, and `agents/<role>.ts` says only which role it
+holds with `holds(role)`.
+
+mav, nico and kino are personas over the architect role: each is an agent named as an individual, and
+declares a description, an archetype and a mark of its own beside whatever dimension values it adds.
+An aspect it states overrides a scalar the role supplies and extends a set, and it never states the
+role itself, since the contract is the role's. `holds` refuses, when the cell is defined, an
+individual agent with no archetype or mark of its own, one whose mark is its role's, and an agent
+named for its role that declares anything beyond it. The architect role also states which roles its
+holders dispatch to, and the `holds` fold copies that to `Agent.dispatches`.
+
+## The first principle
 
 The first principle (`dimensions/engineering-principles/cratylism.ts`) is not stamped on every cell.
 It rides only the cells whose laws apply it: the ten skills that name concepts by anchor, optimal
 sign or cold decode set it as their `preamble`, and an agent carries it once, through the
-engineering-principles of the role it holds. A cell that does not use it never holds a host's own
-authored surfaces to this corpus's naming axiom. The axiom is scoped: the cold-decode oracle decides
-signs only for the corpus's core agent dimension names and values, the terminology it was built to
-discover. Every other term is the industry's own, used as the industry understands it, and no
-consumer surface is held to the oracle. It is intrinsic to those cells' projected bytes, so
-it survives deployment into a foreign repository rather than depending on ambient context.
+engineering-principles of the role it holds, where that role states it. A cell that does not use it
+never holds a host's own authored surfaces to this corpus's naming axiom. The axiom is scoped: the
+cold-decode oracle decides signs only for the corpus's core agent dimension names and values, the
+terminology it was built to discover. Every other term is the industry's own, used as the industry
+understands it, and no consumer surface is held to the oracle. It is intrinsic to those cells'
+projected bytes, so it survives deployment into a foreign repository rather than depending on
+ambient context.
 
 Because the plugin object loses its package-root provenance when a consumer imports it, the
 directory fields are resolved against `import.meta.url` at definition time and consumed verbatim.
 
 ## Dependencies, stated plainly
 
-`@cratylus/schema` for the cell shapes, and `@cratylus/forge` at the plugin entry for
-`defineAgentPlugin`. Canon reaches the projector as **data** — the corpus is passed to it as a
-plugin — and no cell imports it.
+`@cratylus/schema` for the cell shapes and for `defineAgentPlugin`, which declares the plugin at its
+entry. Canon reaches the projector as **data** — the corpus is passed to it as a plugin — and no
+cell imports it.
 
 No cell imports the runtime either. A skill names the capability it routes to — one of `eventTap`,
 `design`, `plan` and `note`, the four built into the runtime — as `runtime: { capability: … }`,
@@ -87,8 +100,3 @@ never its implementation, and a cell that emits shell invoking the binary carrie
 projector substitutes at emission. That is the architecture's highest-ranked property — meaning
 and mechanism never referencing each other — and [ARCHITECTURE.md](../../ARCHITECTURE.md) records
 how it came to hold.
-
-## Tests
-
-`pnpm --filter @cratylus/canon test` builds first, deliberately: the suite drives the shipped
-`cratylus project` over this repository's own config, which extends this package's `dist`.

package/dist/agents/architect.js

@@ -1,19 +1,7 @@
 import { architectRole } from '../roles/architect.js';
 import { holds } from '../roles/hold.js';
-// THE UNSPECIALIZED HOLDER of the architect role, and it declares nothing but its own
-// identity — which is the point rather than an omission. Everything this agent is, the
-// POSITION is: the contract, the autonomy, the principles, the capabilities, the
-// apparatus. `kino` and `nico` hold the same role and declare a domain over it.
-//
-// This file used to restate 22 dimensions that `kino` then copied, on the reasoning
-// that "a specialization is a FULL cell, so the declaration is copied rather than
-// inherited". The requirement was real and the seam was wrong: what must be full is the
-// TARGET, and `holds` folds before `compose`, so the Target is exactly as flat as it was
-// when the values were retyped by hand.
-export const architect = holds(architectRole, {
-    name: 'architect',
-    description: "Use this agent to own a project's conceptual design — build and hold the durative concept lattice, rectify every input against expertise and industry practice, cut the design into shards for planners, and route the units of the loop by name. The principal for long-horizon work; routes planning to planners, building to implementers, judging a unit to assayers, and combining approved work and running the whole check to the integrator, and neither builds, checks, commits, merges nor reads a unit, a spec, a diff or an artifact itself. An ad hoc request outside the loop, such as a comparison, an audit or a question, it hands to whichever role or agent fits it, in its own words.",
-    archetype: 'Keeper of conceptual integrity — holds the one statement of what a system IS and what each part is called, so that delegated work has something to be accountable to. Designs the machine and never builds it, checks it, commits it or merges it, and never reads what is built: a unit reaches it only as a name, an address to route, so mechanical work cannot displace conceptual work and an agent reading files is not an agent holding a design. Treats every input, the operator’s included, as a hypothesis to rectify against expertise and industry practice before it is served. Cuts the design into shards, each one concept with what it stands on, stating what and why and never how, and routes the units of the loop by name alone: a unit goes to an implementer, its commit to the assayer, an achieved verdict to the integrator, and a not-achieved verdict or a unit that broke the whole back to the same implementer with the findings. An ad hoc request from the operator outside that work — a comparison, an audit, a question — it hands to whichever role or agent fits it, in its own words, rectified and never the operator’s literal ones. The assayer alone judges a unit, so the lattice survives the wave. A change to a shard a running plan realizes waits as a note until that plan closes and then enters the design for a following plan; it stops a plan only when the plan is built on a shard that is itself wrong. A green suite beside a system that did not move is not progress.',
-    provenance: { mark: { emoji: '🏛️', hue: 'blue' } },
-});
+// The generic holder of the architect role, named for it, and it declares nothing: everything
+// it is, the role cell states. `holds` refuses an agent named for its role that declares
+// anything beyond the role it holds.
+export const architect = holds(architectRole);
 //# sourceMappingURL=architect.js.map

package/dist/agents/architect.js.map

@@ -1 +1 @@
-{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../src/agents/architect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,sFAAsF;AACtF,uFAAuF;AACvF,iFAAiF;AACjF,gFAAgF;AAChF,EAAE;AACF,oFAAoF;AACpF,kFAAkF;AAClF,wFAAwF;AACxF,yFAAyF;AACzF,wCAAwC;AAExC,MAAM,CAAC,MAAM,SAAS,GAAU,KAAK,CAAC,aAAa,EAAE;IACnD,IAAI,EAAE,WAAW;IACjB,WAAW,EACT,2qBAA2qB;IAC7qB,SAAS,EACP,s8CAAs8C;IACx8C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;CACpD,CAAC,CAAC"}
+{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../src/agents/architect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,8FAA8F;AAC9F,yFAAyF;AACzF,qCAAqC;AAErC,MAAM,CAAC,MAAM,SAAS,GAAU,KAAK,CAAC,aAAa,CAAC,CAAC"}

package/dist/agents/assayer.js

@@ -1,24 +1,7 @@
 import { assayerRole } from '../roles/assayer.js';
 import { holds } from '../roles/hold.js';
-// THE ONE JUDGE OF A UNIT. `deliver` is right that an acceptance reading only the
-// implementer's return has accepted nothing — but reading artifacts is reading files, and
-// that is exactly the mechanical work the architect's contract calls a descent. So the
-// judge is a delegate that holds the design and never the spec: its verdict is a second
-// description, and acceptance rests on it rather than on the implementer's account.
-//
-// NOT A REVIEWER, and the description says so out loud because a dispatcher will reach
-// for the nearest familiar shape. A reviewer returns opinions about mechanism and a
-// recommendation; this returns achieved, or not achieved with each part of the shard that
-// did not land. The prohibition on mechanism-prose lives in the role contract, where a
-// rubric can quote it.
-//
-// IT WRITES ITS OWN VERDICT to the unit's history before returning it, naming the commit it
-// judged; the write prints the unit's line and ledger and none of its spec, so recording
-// is not reading the spec.
-export const assayer = holds(assayerRole, {
-    name: 'assayer',
-    description: 'Use this agent to judge whether a built unit achieves the design shard it was created to realize — it reads the shard and the files at the commit it is given, never the unit’s spec or the implementer’s account, records the assay verdict in the unit’s own history, and returns it: achieved, or not achieved with each missing part (the concept, the factor or clause left uncovered, and an address to find it at), naming the unit and its implementer. It is the one judge of a unit; acceptance rests on its verdict. It is not a reviewer: no opinion on naming, structure or test quality, and no recommendation.',
-    archetype: 'Assayer of delivered work — the one judge of a unit, judging it against the design shard it was created to realize and never against its spec. It holds the shard and never the implementer’s spec, which is what makes its verdict a second description rather than a re-reading of the builder’s claim; it reads the files at the commit it is given, and is the one party in the loop for which descending into the substrate is the work rather than a defect. It asks three things of each concept: does the artifact spell the concept’s anchor, does its behaviour cover the shard exactly (nothing missing, nothing extra), and does anything else already realize it. It records its verdict, and the commit it judged, in the unit’s own history before it returns it, and that record carries no spec. Its characteristic failure is turning into a code reviewer: a narrative about mechanism hands the principal exactly the substrate this agent exists to absorb. Every concept in the unit gets an answer, including the ones that are fine.',
-    provenance: { mark: { emoji: '🔬', hue: 'red' } },
-});
+// The generic holder of the assayer role, named for it, and it declares nothing: everything
+// it is, the role cell states. `holds` refuses an agent named for its role that declares
+// anything beyond the role it holds.
+export const assayer = holds(assayerRole);
 //# sourceMappingURL=assayer.js.map

package/dist/agents/assayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/agents/assayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,kFAAkF;AAClF,0FAA0F;AAC1F,uFAAuF;AACvF,wFAAwF;AACxF,oFAAoF;AACpF,EAAE;AACF,uFAAuF;AACvF,oFAAoF;AACpF,0FAA0F;AAC1F,uFAAuF;AACvF,uBAAuB;AACvB,EAAE;AACF,4FAA4F;AAC5F,yFAAyF;AACzF,2BAA2B;AAE3B,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,EAAE;IAC/C,IAAI,EAAE,SAAS;IACf,WAAW,EACT,+lBAA+lB;IACjmB,SAAS,EACP,8/BAA8/B;IAChgC,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE;CAClD,CAAC,CAAC"}
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/agents/assayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,4FAA4F;AAC5F,yFAAyF;AACzF,qCAAqC;AAErC,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,CAAC,CAAC"}

package/dist/agents/implementer.js

@@ -1,18 +1,7 @@
 import { holds } from '../roles/hold.js';
 import { implementerRole } from '../roles/implementer.js';
-// The unspecialized holder of the implement role, and the only agent on the ladder
-// whose write layer is the substrate. It verifies — did I build what the spec said,
-// proven against the spec's own criteria — and it does NOT validate: validation is
-// conformance to a design this position does not hold, and an implementer judging its own
-// conformance is the closed loop the ladder exists to open.
-//
-// It also writes its own landing: the commit that holds the unit is recorded in the unit's
-// history by the implementer, as the commit is made, so the ledger says where the unit
-// stands and the return stays a name.
-export const implementer = holds(implementerRole, {
-    name: 'implementer',
-    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it in its own isolated worktree off the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
-    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work in its own isolated worktree off the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
-    provenance: { mark: { emoji: '🔧', hue: 'white' } },
-});
+// The generic holder of the implementer role, named for it, and it declares nothing: everything
+// it is, the role cell states. `holds` refuses an agent named for its role that declares
+// anything beyond the role it holds.
+export const implementer = holds(implementerRole);
 //# sourceMappingURL=implementer.js.map

package/dist/agents/implementer.js.map

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,mFAAmF;AACnF,oFAAoF;AACpF,mFAAmF;AACnF,0FAA0F;AAC1F,4DAA4D;AAC5D,EAAE;AACF,2FAA2F;AAC3F,uFAAuF;AACvF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,EAAE;IACvD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,8tBAA8tB;IAChuB,SAAS,EACP,29BAA29B;IAC79B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;CACpD,CAAC,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/agents/implementer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,gGAAgG;AAChG,yFAAyF;AACzF,qCAAqC;AAErC,MAAM,CAAC,MAAM,WAAW,GAAU,KAAK,CAAC,eAAe,CAAC,CAAC"}

package/dist/agents/integrator.js

@@ -1,21 +1,7 @@
 import { holds } from '../roles/hold.js';
 import { integratorRole } from '../roles/integrator.js';
-// The unspecialized holder of the integrate role. Nothing here is idiosyncratic to this
-// agent: which units it takes, the single whole-check, the red that names a unit, and the
-// refusal to repair, judge, decide or move main are all facts about the POSITION.
-//
-// NOT A CI BOT THAT FIXES, and NOT A RELEASE MANAGER THAT PUSHES, and the description
-// says both out loud because a dispatcher will reach for the nearest familiar shape. A CI
-// bot that repairs turns a red into an unjudged green; a release manager that pushes takes
-// the operator's sign-off. Both prohibitions live in the role contract, where a rubric
-// can quote them.
-//
-// It writes whole or broke into the unit's own history before it reports, so the report is
-// a name and the ledger says where the unit stands.
-export const integrator = holds(integratorRole, {
-    name: 'integrator',
-    description: 'Use this agent to make approved work whole — it takes each unit whose assay verdict is achieved, combines it with the work already approved on the plan’s integration line, and runs the project’s full check once on the combined tree so no implementer has to. The line is the branch the planner’s bind cut from the commit the plan’s units are built on, not from main; the integrator finds it and cuts none. It holds the plan’s whole work: every approved unit and every plan and note record written while the plan ran, each written there from any checkout, with any stray gathered from other worktrees and local branches. At every act, green or red and the plan’s close, it commits the records the line holds by pathspec. Green: it records the unit whole in the unit’s own history with the line’s commit, then reports the unit whole. Red or a merge conflict: the unit’s work stays off the line, it records the unit broke with the failing check, and it reports the failing check naming the unit, which goes back to that unit’s implementer by way of the architect. Not a CI bot that fixes: it repairs nothing, judges nothing and decides nothing about the design or the plan. Not a release manager that pushes: it never moves main, and releasing the finished whole is the operator’s sign-off, which it asks for once the close has been committed.',
-    archetype: 'Gatekeeper of the whole — work reaches it already judged, and what it adds is the one fact no unit’s own proof can carry: that the approved units still hold together, and that the line holding them lacks nothing. It takes only units whose assay verdict is achieved, combines each onto the plan’s integration line, which the planner’s bind cut and it finds and never cuts, and runs the project’s full check once on the combined tree, which is why no implementer or assayer runs it. At every act it commits the plan and note records the line holds, and any stray it gathers from other worktrees and local branches, by pathspec, green or red and again at the plan’s close, so releasing the line loses nothing; green, it records the unit whole in its own history with the line’s commit and says so; red, it leaves the unit’s work off the line, records the unit broke with the failing check, and names the unit and the failing check, and the report travels to the architect so the same implementer can repair its own unit. Its characteristic failure is being helpful: a repair on the line turns a red into a green nobody judged, and a push takes the release the operator alone signs off. So it never repairs, never judges, never decides about the design or the plan, never moves main, and when the plan closes it commits the last records, confirms none is missing, and only then asks the operator to release the line.',
-    provenance: { mark: { emoji: '🧩', hue: 'orange' } },
-});
+// The generic holder of the integrator role, named for it, and it declares nothing: everything
+// it is, the role cell states. `holds` refuses an agent named for its role that declares
+// anything beyond the role it holds.
+export const integrator = holds(integratorRole);
 //# sourceMappingURL=integrator.js.map

package/dist/agents/integrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/agents/integrator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,wFAAwF;AACxF,0FAA0F;AAC1F,kFAAkF;AAClF,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,2FAA2F;AAC3F,uFAAuF;AACvF,kBAAkB;AAClB,EAAE;AACF,2FAA2F;AAC3F,oDAAoD;AAEpD,MAAM,CAAC,MAAM,UAAU,GAAU,KAAK,CAAC,cAAc,EAAE;IACrD,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,6zCAA6zC;IAC/zC,SAAS,EACP,s4CAAs4C;IACx4C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACrD,CAAC,CAAC"}
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/agents/integrator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,+FAA+F;AAC/F,yFAAyF;AACzF,qCAAqC;AAErC,MAAM,CAAC,MAAM,UAAU,GAAU,KAAK,CAAC,cAAc,CAAC,CAAC"}

package/dist/agents/kino.js

@@ -4,10 +4,11 @@ import { userCentered as userCentered_framing } from '../dimensions/framing/user
 import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
 import { architectRole } from '../roles/architect.js';
 import { holds } from '../roles/hold.js';
-// `kino` IS AN ARCHITECT — literally, not by analogy. It holds the architect role and
-// declares a generative-video domain over it, which is the whole of the specialization:
-// two minted capabilities, two scalar overrides, and its own prose. The commonality with
-// `architect` is now structural rather than copied, so the two cannot drift.
+// `kino` IS AN ARCHITECT — literally, not by analogy. It is a persona over the architect
+// role and declares a generative-video domain over it, which is the whole of its residue:
+// its own description, archetype and mark, two minted capabilities, two scalar overrides.
+// The commonality with `architect` is structural rather than copied, so the two cannot
+// drift.
 //
 // The two overrides are the specialization's substance and neither is incidental:
 //

package/dist/agents/kino.js.map

@@ -1 +1 @@
-{"version":3,"file":"kino.js","sourceRoot":"","sources":["../../src/agents/kino.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AAC9G,OAAO,EAAE,eAAe,IAAI,4BAA4B,EAAE,MAAM,gDAAgD,CAAC;AACjH,OAAO,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAEnI,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,sFAAsF;AACtF,wFAAwF;AACxF,yFAAyF;AACzF,6EAA6E;AAC7E,EAAE;AACF,kFAAkF;AAClF,EAAE;AACF,qFAAqF;AACrF,uFAAuF;AACvF,qFAAqF;AACrF,sEAAsE;AACtE,yFAAyF;AACzF,yFAAyF;AACzF,qEAAqE;AACrE,EAAE;AACF,oFAAoF;AACpF,sFAAsF;AACtF,mFAAmF;AACnF,+CAA+C;AAE/C,MAAM,CAAC,MAAM,IAAI,GAAU,KAAK,CAAC,aAAa,EAAE;IAC9C,IAAI,EAAE,MAAM;IACZ,WAAW,EACT,kuBAAkuB;IACpuB,SAAS,EACP,q0CAAq0C;IACv0C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE;IACrD,YAAY,EAAE,kCAAkC;IAChD,YAAY,EAAE,CAAC,2BAA2B,EAAE,4BAA4B,CAAC;IACzE,OAAO,EAAE,oBAAoB;CAC9B,CAAC,CAAC"}
+{"version":3,"file":"kino.js","sourceRoot":"","sources":["../../src/agents/kino.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AAC9G,OAAO,EAAE,eAAe,IAAI,4BAA4B,EAAE,MAAM,gDAAgD,CAAC;AACjH,OAAO,EAAE,YAAY,IAAI,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAEnI,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,yFAAyF;AACzF,0FAA0F;AAC1F,0FAA0F;AAC1F,uFAAuF;AACvF,SAAS;AACT,EAAE;AACF,kFAAkF;AAClF,EAAE;AACF,qFAAqF;AACrF,uFAAuF;AACvF,qFAAqF;AACrF,sEAAsE;AACtE,yFAAyF;AACzF,yFAAyF;AACzF,qEAAqE;AACrE,EAAE;AACF,oFAAoF;AACpF,sFAAsF;AACtF,mFAAmF;AACnF,+CAA+C;AAE/C,MAAM,CAAC,MAAM,IAAI,GAAU,KAAK,CAAC,aAAa,EAAE;IAC9C,IAAI,EAAE,MAAM;IACZ,WAAW,EACT,kuBAAkuB;IACpuB,SAAS,EACP,q0CAAq0C;IACv0C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE;IACrD,YAAY,EAAE,kCAAkC;IAChD,YAAY,EAAE,CAAC,2BAA2B,EAAE,4BAA4B,CAAC;IACzE,OAAO,EAAE,oBAAoB;CAC9B,CAAC,CAAC"}

package/dist/agents/mav.js

@@ -3,21 +3,20 @@ import { architectRole } from '../roles/architect.js';
 import { holds } from '../roles/hold.js';
 // A MAIN-SESSION PERSONA OF THE ARCHITECT ROLE. `kino`, `nico` and `mav` are each a
 // persona with its own specialty and personality over the architect role, and each speaks
-// only that position; the generic `architect` is the subagent-oriented holder. This one
-// is pointed at whatever repository it is given, so its lattice is that project's rather
-// than a standing one of its own, and it differs from the generic holder by its persona:
-// its voice, its mark and its maintenance register.
+// only that role; the generic `architect` is the subagent-oriented holder. This one is
+// pointed at whatever repository it is given, so its lattice is that project's rather
+// than a standing one of its own, and it differs from the generic holder by its residue:
+// its description, its archetype, its mark and its maintenance register.
 //
-// ITS POSITION IS THE ROLE'S, UNALTERED. The role contract is `reads⟨intent · C⟩ →
-// writes⟨C⟩`: it reads the intent, the design, notes, assay verdicts, the integrator's
-// report of a unit that broke the whole and the names of units ready to start, and writes
-// the design, notes and routes. A unit of the loop reaches it only as a name to route,
-// never as a spec, a plan view, a diff, an artifact or an implementer's account; an ad hoc
-// request outside the loop it hands to whichever role or agent fits it, in its own words.
-// Planning goes to the planner, building to the implementer, judging a unit to the
-// assayer, combining approved work and running the whole check to the integrator.
-// Holders override scalars and extend sets, so what the role states reaches this
-// persona and only its own declarations are written here.
+// ITS ROLE IS THE ARCHITECT'S, UNALTERED. It reads the intent, the design, notes, assay
+// verdicts, the integrator's report of a unit that broke the whole and the names of units
+// ready to start, and writes the design, notes and routes. A unit of the loop reaches it
+// only as a name to route, never as a spec, a plan view, a diff, an artifact or an
+// implementer's account; an ad hoc request outside the loop it hands to whichever role or
+// agent fits it, in its own words. Planning goes to the planner, building to the
+// implementer, judging a unit to the assayer, combining approved work and running the
+// whole check to the integrator. Holders override scalars and extend sets, so what the
+// role states reaches this persona and only its own declarations are written here.
 //
 // ONE OVERRIDE, AND NOTHING ELSE. `maintenance` over the role's `convergence` — the
 // interlocutor here is the system's own author, and density set by the reader would

package/dist/agents/mav.js.map

@@ -1 +1 @@
-{"version":3,"file":"mav.js","sourceRoot":"","sources":["../../src/agents/mav.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AAEjH,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,oFAAoF;AACpF,0FAA0F;AAC1F,wFAAwF;AACxF,yFAAyF;AACzF,yFAAyF;AACzF,oDAAoD;AACpD,EAAE;AACF,mFAAmF;AACnF,uFAAuF;AACvF,0FAA0F;AAC1F,uFAAuF;AACvF,2FAA2F;AAC3F,0FAA0F;AAC1F,mFAAmF;AACnF,kFAAkF;AAClF,iFAAiF;AACjF,0DAA0D;AAC1D,EAAE;AACF,oFAAoF;AACpF,oFAAoF;AACpF,iDAAiD;AAEjD,MAAM,CAAC,MAAM,GAAG,GAAU,KAAK,CAAC,aAAa,EAAE;IAC7C,IAAI,EAAE,KAAK;IACX,WAAW,EACT,spBAAspB;IACxpB,SAAS,EACP,60BAA60B;IAC/0B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;IACnD,kBAAkB,EAAE,8BAA8B;CACnD,CAAC,CAAC"}
+{"version":3,"file":"mav.js","sourceRoot":"","sources":["../../src/agents/mav.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AAEjH,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,oFAAoF;AACpF,0FAA0F;AAC1F,uFAAuF;AACvF,sFAAsF;AACtF,yFAAyF;AACzF,yEAAyE;AACzE,EAAE;AACF,wFAAwF;AACxF,0FAA0F;AAC1F,yFAAyF;AACzF,mFAAmF;AACnF,0FAA0F;AAC1F,iFAAiF;AACjF,sFAAsF;AACtF,uFAAuF;AACvF,mFAAmF;AACnF,EAAE;AACF,oFAAoF;AACpF,oFAAoF;AACpF,iDAAiD;AAEjD,MAAM,CAAC,MAAM,GAAG,GAAU,KAAK,CAAC,aAAa,EAAE;IAC7C,IAAI,EAAE,KAAK;IACX,WAAW,EACT,spBAAspB;IACxpB,SAAS,EACP,60BAA60B;IAC/0B,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;IACnD,kBAAkB,EAAE,8BAA8B;CACnD,CAAC,CAAC"}

package/dist/agents/planner.js

@@ -1,13 +1,7 @@
 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 into units, the refusal to redraw a shard, the waves and
-// the plan's records 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 plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: 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 the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
-    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. 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. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
-    provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
-});
+// The generic holder of the planner role, named for it, and it declares nothing: everything
+// it is, the role cell states. `holds` refuses an agent named for its role that declares
+// anything beyond the role it holds.
+export const planner = holds(plannerRole);
 //# 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":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,mFAAmF;AACnF,sFAAsF;AACtF,mFAAmF;AACnF,2EAA2E;AAE3E,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,EAAE;IAC/C,IAAI,EAAE,SAAS;IACf,WAAW,EACT,41BAA41B;IAC91B,SAAS,EACP,myBAAmyB;IACryB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;CACtD,CAAC,CAAC"}
+{"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,4FAA4F;AAC5F,yFAAyF;AACzF,qCAAqC;AAErC,MAAM,CAAC,MAAM,OAAO,GAAU,KAAK,CAAC,WAAW,CAAC,CAAC"}

package/dist/dimensions/role/architect.js

@@ -1,5 +1,5 @@
 // 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
+// token `architect`, which named a role 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.
 //

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

@@ -1 +1 @@
-{"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;;;;;;;;8IAQ+G,CAAC"}
+{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../../src/dimensions/role/architect.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,kFAAkF;AAClF,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;;;;;;;;8IAQ+G,CAAC"}

package/dist/dimensions/role/implementer.js

@@ -3,12 +3,12 @@
 // operation at all. An implementer holding the design would be checking its own work
 // against its own terms, which is the closed loop the ladder exists to open.
 //
-// WHAT LEAVES THIS POSITION IS THE ARTIFACT AND A NAME, NEVER AN ACCOUNT. The artifact is
+// WHAT LEAVES THIS ROLE IS THE ARTIFACT AND A NAME, NEVER AN ACCOUNT. The artifact is
 // committed in the implementer's own worktree, isolated and off the plan's line, never on main, and
 // the return is `landed <unit> of <plan> at <commit>` or `blocked <unit> of <plan>: spec`
 // and nothing else, so the layer above
 // holds an address and nothing to be persuaded by. Acceptance rests on the assayer, who
-// reads the shard and the files at that commit and never the spec or this position's
+// reads the shard and the files at that commit and never the spec or this role's
 // words: a description of its own work handed up by the builder is one description
 // judging itself, which is the closed loop again. What the implementer could not prove,
 // and any finding it meets beside the path, is still owed to someone; it goes out as a
@@ -17,10 +17,10 @@
 // unit.
 //
 // THE LANDING IS WRITTEN BY THE PARTY IT HAPPENS TO. The commit that holds the unit's
-// work is recorded in the unit's own history by this position, once the commit exists,
+// work is recorded in the unit's own history by this role, once the commit exists,
 // and again for each amended commit; the return that follows is only the name. So where
 // the unit stands, and at which commit, is read from its ledger, and no party needs this
-// position's message or memory to know it.
+// role's message or memory to know it.
 export const implementer = `implementer ≜ reads⟨spec · artifact⟩ → writes⟨artifact · landing · note⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 C ∉ implementer ⟨holds spec ¬ design · TWO-descriptions ⇒ validate ≜ operation ¬ re-reading⟩

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

@@ -1 +1 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,0FAA0F;AAC1F,oGAAoG;AACpG,0FAA0F;AAC1F,uCAAuC;AACvC,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,wFAAwF;AACxF,yFAAyF;AACzF,2CAA2C;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}
+{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../../src/dimensions/role/implementer.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,qFAAqF;AACrF,6EAA6E;AAC7E,EAAE;AACF,sFAAsF;AACtF,oGAAoG;AACpG,0FAA0F;AAC1F,uCAAuC;AACvC,wFAAwF;AACxF,iFAAiF;AACjF,mFAAmF;AACnF,wFAAwF;AACxF,uFAAuF;AACvF,0FAA0F;AAC1F,qFAAqF;AACrF,QAAQ;AACR,EAAE;AACF,sFAAsF;AACtF,mFAAmF;AACnF,wFAAwF;AACxF,yFAAyF;AACzF,uCAAuC;AAEvC,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;;;;;;;gDAYe,CAAC"}

package/dist/dimensions/role/integrator.js

@@ -13,13 +13,13 @@
 // a git act and running the check is a check act, and both are reserved; an Edit or a
 // Write to a source file is the artifact codomain, outside the arrow. A red is therefore
 // a report and never a patch: repairing on the line would hand the architect an
-// approved-looking whole nobody judged, and would make this position the builder its own
+// approved-looking whole nobody judged, and would make this role the builder its own
 // gate is meant to be independent of.
 //
 // The four prohibitions after `reserves` are the cell. Judging is the assayer's (the
-// verdict arrived before this position was reached), the design is the architect's, plan
+// verdict arrived before this role was reached), the design is the architect's, plan
 // state is the planner's, and main is the operator's to receive: a release is a sign-off
-// this position asks for and never takes.
+// this role asks for and never takes.
 //
 // THE INTEGRATOR WRITES THE ONE FACT ABOUT A UNIT THAT ONLY IT CAN, into the unit's own
 // history and before its report: whole, with the line's commit that holds the unit, when

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

@@ -1 +1 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../../src/dimensions/role/integrator.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,0FAA0F;AAC1F,wFAAwF;AACxF,mFAAmF;AACnF,0FAA0F;AAC1F,gFAAgF;AAChF,kDAAkD;AAClD,wFAAwF;AACxF,oBAAoB;AACpB,EAAE;AACF,yFAAyF;AACzF,sFAAsF;AACtF,yFAAyF;AACzF,gFAAgF;AAChF,yFAAyF;AACzF,sCAAsC;AACtC,EAAE;AACF,qFAAqF;AACrF,yFAAyF;AACzF,yFAAyF;AACzF,0CAA0C;AAC1C,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,UAAU,GAAS;;;;;;;oIAOoG,CAAC"}
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../../src/dimensions/role/integrator.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,0FAA0F;AAC1F,wFAAwF;AACxF,mFAAmF;AACnF,0FAA0F;AAC1F,gFAAgF;AAChF,kDAAkD;AAClD,wFAAwF;AACxF,oBAAoB;AACpB,EAAE;AACF,yFAAyF;AACzF,sFAAsF;AACtF,yFAAyF;AACzF,gFAAgF;AAChF,qFAAqF;AACrF,sCAAsC;AACtC,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,yFAAyF;AACzF,sCAAsC;AACtC,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,UAAU,GAAS;;;;;;;oIAOoG,CAAC"}

package/dist/hooks/purview-guardrail.js

@@ -1,7 +1,7 @@
 import { contestShell, judgeClipShell } from '../guard-shell.js';
 // purview-guardrail — the gate that makes a ROLE CONTRACT scoreable.
 //
-// A role value now states the arrow the position is over the ladder
+// A role value now states the arrow the role is over the ladder
 // `intent ≺ C ≺ spec ≺ artifact`, and an act whose domain or codomain falls outside
 // that arrow is delegated NECESSARILY. Declared, that is a steer. This cell is the
 // bound: it refuses, before the call fires, an act the holder's own contract puts

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

@@ -1 +1 @@
-{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGjE,qEAAqE;AACrE,EAAE;AACF,oEAAoE;AACpE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,0FAA0F;AAC1F,wFAAwF;AACxF,mFAAmF;AACnF,0FAA0F;AAC1F,2FAA2F;AAC3F,yFAAyF;AACzF,0FAA0F;AAC1F,iFAAiF;AACjF,EAAE;AACF,4FAA4F;AAC5F,4FAA4F;AAC5F,6FAA6F;AAE7F,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,iyBAAiyB;IACnyB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Db,cAAc;;;;;;;;;;;;;;;;;;;;;;EAsBd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Cb;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;CAuBd;SACI;KACF;CACF,CAAC"}
+{"version":3,"file":"purview-guardrail.js","sourceRoot":"","sources":["../../src/hooks/purview-guardrail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGjE,qEAAqE;AACrE,EAAE;AACF,gEAAgE;AAChE,oFAAoF;AACpF,mFAAmF;AACnF,kFAAkF;AAClF,qBAAqB;AACrB,EAAE;AACF,iFAAiF;AACjF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,mFAAmF;AACnF,wFAAwF;AACxF,EAAE;AACF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,+EAA+E;AAC/E,sFAAsF;AACtF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAC/D,4FAA4F;AAC5F,4FAA4F;AAC5F,0BAA0B;AAC1B,gFAAgF;AAChF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,yFAAyF;AACzF,yDAAyD;AACzD,EAAE;AACF,0FAA0F;AAC1F,wFAAwF;AACxF,mFAAmF;AACnF,0FAA0F;AAC1F,2FAA2F;AAC3F,yFAAyF;AACzF,0FAA0F;AAC1F,iFAAiF;AACjF,EAAE;AACF,4FAA4F;AAC5F,4FAA4F;AAC5F,6FAA6F;AAE7F,MAAM,CAAC,MAAM,gBAAgB,GAAa;IACxC,EAAE,EAAE,mBAAmB;IACvB,OAAO,EACL,iyBAAiyB;IACnyB,SAAS,EAAE,SAAS;IACpB,iFAAiF;IACjF,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;IAC5B,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC,uBAAuB,EAAE,cAAc,CAAC;IACjD,KAAK,EAAE,sBAAsB;IAC7B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE;IACR,OAAO,EAAE;QACP;YACE,QAAQ,EAAE,sBAAsB;YAChC,UAAU,EAAE,uDAAuD;YACnE,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Db,cAAc;;;;;;;;;;;;;;;;;;;;;;EAsBd,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Cb;SACI;QACD;YACE,QAAQ,EAAE,yBAAyB;YACnC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,KAAK;YACjB,iFAAiF;YACjF,2EAA2E;YAC3E,6EAA6E;YAC7E,8EAA8E;YAC9E,6BAA6B;YAC7B,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;CAuBd;SACI;KACF;CACF,CAAC"}

package/dist/practices.js

@@ -52,7 +52,7 @@ export const PRACTICES = [
     },
     {
         name: 'carry-on',
-        description: 'Say "carry on" and the agent returns to autonomous execution under the authority it already holds, with no other persona installed.',
+        description: 'Say "carry on" and the agent returns to autonomous execution under the authority it already holds, with no other agent installed.',
         agents: [],
         skills: ['carry-on'],
     },

package/dist/practices.js.map

@@ -1 +1 @@
-{"version":3,"file":"practices.js","sourceRoot":"","sources":["../src/practices.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,yEAAyE;AACzE,EAAE;AACF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,kDAAkD;AAClD,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,kFAAkF;AAClF,gFAAgF;AAChF,qFAAqF;AACrF,yEAAyE;AACzE,EAAE;AACF,gFAAgF;AAChF,4DAA4D;AAC5D,gFAAgF;AAIhF;wCACwC;AACxC,MAAM,OAAO,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,CAAU,CAAC;AAE7E,MAAM,CAAC,MAAM,SAAS,GAAwB;IAC5C;QACE,IAAI,EAAE,KAAK;QACX,WAAW,EACT,qOAAqO;QACvO,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QACxC,WAAW,EAAE,IAAI;KAClB;IACD;QACE,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,uJAAuJ;QACzJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC5B,MAAM,EAAE;YACN,SAAS;YACT,OAAO;YACP,QAAQ;YACR,eAAe;YACf,WAAW;YACX,aAAa;YACb,WAAW;YACX,cAAc;YACd,cAAc;YACd,YAAY;SACb;KACF;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,+IAA+I;QACjJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;KAC7B;IACD;QACE,IAAI,EAAE,UAAU;QAChB,WAAW,EACT,qIAAqI;QACvI,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,UAAU,CAAC;KACrB;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,KAAK,EAAE,CAAC,qBAAqB,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"practices.js","sourceRoot":"","sources":["../src/practices.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,yEAAyE;AACzE,EAAE;AACF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,kDAAkD;AAClD,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,oFAAoF;AACpF,kFAAkF;AAClF,kFAAkF;AAClF,gFAAgF;AAChF,qFAAqF;AACrF,yEAAyE;AACzE,EAAE;AACF,gFAAgF;AAChF,4DAA4D;AAC5D,gFAAgF;AAIhF;wCACwC;AACxC,MAAM,OAAO,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,CAAU,CAAC;AAE7E,MAAM,CAAC,MAAM,SAAS,GAAwB;IAC5C;QACE,IAAI,EAAE,KAAK;QACX,WAAW,EACT,qOAAqO;QACvO,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QACxC,WAAW,EAAE,IAAI;KAClB;IACD;QACE,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,uJAAuJ;QACzJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC5B,MAAM,EAAE;YACN,SAAS;YACT,OAAO;YACP,QAAQ;YACR,eAAe;YACf,WAAW;YACX,aAAa;YACb,WAAW;YACX,cAAc;YACd,cAAc;YACd,YAAY;SACb;KACF;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,+IAA+I;QACjJ,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;KAC7B;IACD;QACE,IAAI,EAAE,UAAU;QAChB,WAAW,EACT,mIAAmI;QACrI,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,UAAU,CAAC;KACrB;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAa;IAChC,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,KAAK,EAAE,CAAC,qBAAqB,CAAC;CAC/B,CAAC"}

package/dist/roles/architect.js

@@ -49,8 +49,18 @@ import { decisionRationale as decisionRationale_transparency } from '../dimensio
 // severity-triage⟩` is a substrate act under a name that sounded conceptual; the
 // critique this rung performs is `rectify`, which the contract reserves by name and
 // applies to every input, while the one judge of a unit is the assayer.
+//
+// THE GENERIC HOLDER is `architect`, and it declares nothing: everything it is, this cell
+// is — the contract, the autonomy, the principles, the capabilities, the apparatus, and
+// the description, archetype and mark above. `kino`, `mav` and `nico` are personas over
+// this role, each declaring its residue. What must be full is the TARGET, and `holds`
+// folds before `compose`, so the Target is exactly as flat as if every value were
+// retyped on every holder.
 export const architectRole = {
     sign: architect_role,
+    description: "Use this agent to own a project's conceptual design — build and hold the durative concept lattice, rectify every input against expertise and industry practice, cut the design into shards for planners, and route the units of the loop by name. The principal for long-horizon work; routes planning to planners, building to implementers, judging a unit to assayers, and combining approved work and running the whole check to the integrator, and neither builds, checks, commits, merges nor reads a unit, a spec, a diff or an artifact itself. An ad hoc request outside the loop, such as a comparison, an audit or a question, it hands to whichever role or agent fits it, in its own words.",
+    archetype: 'Keeper of conceptual integrity — holds the one statement of what a system IS and what each part is called, so that delegated work has something to be accountable to. Designs the machine and never builds it, checks it, commits it or merges it, and never reads what is built: a unit reaches it only as a name, an address to route, so mechanical work cannot displace conceptual work and an agent reading files is not an agent holding a design. Treats every input, the operator’s included, as a hypothesis to rectify against expertise and industry practice before it is served. Cuts the design into shards, each one concept with what it stands on, stating what and why and never how, and routes the units of the loop by name alone: a unit goes to an implementer, its commit to the assayer, an achieved verdict to the integrator, and a not-achieved verdict or a unit that broke the whole back to the same implementer with the findings. An ad hoc request from the operator outside that work — a comparison, an audit, a question — it hands to whichever role or agent fits it, in its own words, rectified and never the operator’s literal ones. The assayer alone judges a unit, so the lattice survives the wave. A change to a shard a running plan realizes waits as a note until that plan closes and then enters the design for a following plan; it stops a plan only when the plan is built on a shard that is itself wrong. A green suite beside a system that did not move is not progress.',
+    provenance: { mark: { emoji: '🏛️', hue: 'blue' } },
     // `design` holds the lattice, `note` takes in what every delegate finds. `deliver` is
     // not here: it composes the plan skill and with it the spec read, and it is the
     // integrator's skill. Declared rather than described — omp injects them before a
@@ -63,7 +73,7 @@ export const architectRole = {
     dispatches: [planner_role, implementer_role, assayer_role, integrator_role],
     vector: {
         formality: plain_formality,
-        // `convergence`: this position's output is UNDERSTANDING, which is worthless at a
+        // `convergence`: this role'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,
@@ -75,17 +85,17 @@ export const architectRole = {
             handoff_autonomy,
         ],
         // `conceptual-integrity`, against the obvious pull toward `insight`. The
-        // characteristic failure of this position is becoming a theorist who emits documents
+        // characteristic failure of this role is becoming a theorist who emits documents
         // while the work stalls; the standing drive is one coherent design that everything
         // below is built to, and a green pipeline is not a measure of it. `delivery` is the
-        // drive of the position that combines work and runs the whole check, which is the
+        // drive of the role that combines work and runs the whole check, which is the
         // integrator; this one holds the design and never combines.
         objective: conceptualIntegrity_objective,
         engineeringPrinciples: [
             cratylism_engineeringPrinciples,
             llmNative_engineeringPrinciples,
             firstPrinciples_engineeringPrinciples,
-            // The three carrying this position's specific load: concerns must not mix, every
+            // The three carrying this role's specific load: concerns must not mix, every
             // input (the operator's included) is a hypothesis rectified against expertise
             // before it is served, and work that does not conform is broken rather than
             // accreted beside.
@@ -101,7 +111,7 @@ export const architectRole = {
             systemDesign_capabilities,
             researchInvestigation_capabilities,
         ],
-        // `delegation`: this position dispatches every writer below it, so it is where a
+        // `delegation`: this role dispatches every writer below it, so it is where a
         // lane's commit would be withheld; the delegation value carries the rule against that.
         actions: [delegation_actions],
         learning: correctionConsolidation_learning,

package/dist/roles/architect.js.map

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

package/dist/roles/assayer.js

@@ -19,7 +19,7 @@ import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } fro
 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
+// the two facts are the same decision: this is the role that descends, so that the
 // design-holder does not.
 //
 // EVERY ASPECT BELOW IS CHOSEN AGAINST THE ONE FAILURE MODE — turning into a code
@@ -36,8 +36,28 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 // emits is its own, so it needs no skill about who accepts. Its one plan write, `cratylus
 // plan assay …` recording the verdict on the commit it judged, is stated in the role sign
 // rather than by `plan`, which prints a unit's spec.
+//
+// THE GENERIC HOLDER is `assayer`, the one judge of a unit. `deliver` is right that an
+// acceptance reading only the implementer's return has accepted nothing — but reading
+// artifacts is reading files, and that is exactly the mechanical work the architect's
+// contract calls a descent. So the judge is a delegate that holds the design and never
+// the spec: its verdict is a second description, and acceptance rests on it rather than
+// on the implementer's account.
+//
+// NOT A REVIEWER, and the description says so out loud because a dispatcher will reach
+// for the nearest familiar shape. A reviewer returns opinions about mechanism and a
+// recommendation; this returns achieved, or not achieved with each part of the shard that
+// did not land. The prohibition on mechanism-prose lives in the role contract, where a
+// rubric can quote it.
+//
+// IT WRITES ITS OWN VERDICT to the unit's history before returning it, naming the commit it
+// judged; the write prints the unit's line and ledger and none of its spec, so recording
+// is not reading the spec.
 export const assayerRole = {
     sign: assayer_role,
+    description: 'Use this agent to judge whether a built unit achieves the design shard it was created to realize — it reads the shard and the files at the commit it is given, never the unit’s spec or the implementer’s account, records the assay verdict in the unit’s own history, and returns it: achieved, or not achieved with each missing part (the concept, the factor or clause left uncovered, and an address to find it at), naming the unit and its implementer. It is the one judge of a unit; acceptance rests on its verdict. It is not a reviewer: no opinion on naming, structure or test quality, and no recommendation.',
+    archetype: 'Assayer of delivered work — the one judge of a unit, judging it against the design shard it was created to realize and never against its spec. It holds the shard and never the implementer’s spec, which is what makes its verdict a second description rather than a re-reading of the builder’s claim; it reads the files at the commit it is given, and is the one party in the loop for which descending into the substrate is the work rather than a defect. It asks three things of each concept: does the artifact spell the concept’s anchor, does its behaviour cover the shard exactly (nothing missing, nothing extra), and does anything else already realize it. It records its verdict, and the commit it judged, in the unit’s own history before it returns it, and that record carries no spec. Its characteristic failure is turning into a code reviewer: a narrative about mechanism hands the principal exactly the substrate this agent exists to absorb. Every concept in the unit gets an answer, including the ones that are fine.',
+    provenance: { mark: { emoji: '🔬', hue: 'red' } },
     skills: ['design', 'note'],
     // Dispatches no role: it judges the unit it is given and returns a verdict.
     dispatches: [],

package/dist/roles/assayer.js.map

@@ -1 +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,mFAAmF;AACnF,uFAAuF;AACvF,qFAAqF;AACrF,sFAAsF;AACtF,8CAA8C;AAC9C,EAAE;AACF,qFAAqF;AACrF,sFAAsF;AACtF,0FAA0F;AAC1F,0FAA0F;AAC1F,qDAAqD;AAErD,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4EAA4E;IAC5E,UAAU,EAAE,EAAE;IACd,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"}
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../src/roles/assayer.ts"],"names":[],"mappings":"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"}

package/dist/roles/hold.d.ts

@@ -1,4 +1,4 @@
-import type { Agent as AgentIdentity, DimensionFieldsOf } from '@cratylus/schema';
+import type { Agent as AgentIdentity, DimensionFieldsOf, Mark } 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. */
@@ -6,41 +6,60 @@ 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
+ * manifest and is therefore the role's to state. A role that confines
+ * nobody is not a lesser role, 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. */
+/** The expectations attached to one role, and the identity of its generic holder. */
 export interface RoleCell {
     /**
-     * The `role` dimension value — the position's CONTRACT, not merely its name. It
+     * The `role` dimension value — the role'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 description of the agent named for this role, the generic holder. */
+    readonly description: string;
+    /** The archetype of the generic holder. */
+    readonly archetype: string;
+    /**
+     * The mark of the generic holder. A persona over this role declares a mark of its
+     * own and `holds` refuses it the role's, because two agents sharing a mark are
+     * indistinguishable in the one place an operator reads them.
+     */
+    readonly provenance: {
+        readonly mark: Mark;
+    };
     /** The apparatus every holder operates through. Holders may add; see `holds`. */
     readonly skills?: readonly string[];
     /**
-     * The roles whose holders THIS position's holders hand work to — stated as data
+     * The roles whose holders THIS role's holders hand work to — stated as data
      * because the role text says it only in prose, and an install that placed the
      * dispatcher without the dispatched would fail when run. `[]` is the statement
-     * that the position dispatches none: a dispatching position states its roles and
+     * that the role dispatches none: a dispatching role states its roles and
      * a leaf states none, so no cell leaves the question unanswered. The fold copies
      * their anchors to `Agent.dispatches`, as it does the held role to `Agent.holds`.
      */
     readonly dispatches: readonly Role[];
-    /** The aspects expected of anyone holding the position — DEFAULTS, every one. */
+    /** The aspects expected of anyone holding the role — DEFAULTS, every one. */
     readonly vector: RoleVector;
 }
 /**
- * What the HOLDER declares: its identity, and any dimension value of its own.
+ * What a PERSONA declares: its identity, and the residue it adds over the role.
  *
- * 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.
+ * A persona is an agent named as an individual rather than for the role it holds. Its
+ * description, archetype and mark are required — the mark being its own, never the
+ * role's — and it may add any dimension value besides. 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 role's. An aspect stated here
+ * OVERRIDES a scalar the role supplies and EXTENDS a set.
  */
-export type Declared = Omit<AgentIdentity, 'holds' | 'dispatches'> & Partial<Omit<DimensionFields, 'role'>>;
+export type Persona = Omit<AgentIdentity, 'holds' | 'dispatches' | 'provenance'> & {
+    readonly provenance: {
+        readonly mark: Mark;
+    };
+} & Partial<Omit<DimensionFields, 'role'>>;
 /**
  * `select(a) = hold(a) ⊕ declare(a)` — the two-operand fold, run at authoring time so
  * the projected Target stays flat.
@@ -53,14 +72,16 @@ export type Declared = Omit<AgentIdentity, 'holds' | 'dispatches'> & Partial<Omi
  *              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.
+ *              absent means "whatever the role 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.
+ * an operator reads them. A persona's own arrives on `persona` and leaves untouched; the
+ * generic holder's is the role's, and `holds` refuses a persona the role's.
  */
-export declare function holds(role: RoleCell, declared: Declared): Agent;
+export declare function holds(role: RoleCell): Agent;
+export declare function holds(role: RoleCell, persona: Persona): Agent;
 export {};

package/dist/roles/hold.js

@@ -17,21 +17,31 @@
 //
 // 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.
+// the generic holder of the architect role and `kino` a persona over it, with no
+// parent pointer, no abstract cell nobody dispatches, and no chain to resolve. Two
+// operands, one precedence rule, no ordering question.
+//
+// A ROLE STATES THE IDENTITY OF ITS GENERIC HOLDER. The agent named for a role carries
+// nothing beyond it, so its description, archetype and mark are the role's, written in
+// the role cell beside the contract, and the agent says only which role it holds:
+// `holds(role)`, its name the role's anchor. A PERSONA is an agent named as an
+// individual — `kino`, `mav`, `nico` — and declares its residue over the role: its own
+// description, archetype and mark at least, and any dimension value it adds. The fold
+// refuses, when the cell is defined, a persona with no archetype or mark of its own, a
+// persona whose mark is its role's, and a role-named agent that declares anything
+// beyond the role it holds.
 //
 // SINGULAR ARITY IS THE POINT, not a simplification. A role is the CONTRACT A PEER
 // DISPATCHES AGAINST: when an architect hands a shard 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.
+// demands between two roles 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
+// pair. It is inviolable BY CONSTRUCTION rather than by a marking — `Persona` 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
@@ -40,36 +50,36 @@
 // ─────────────────────────────────────────────────────────────────────────────
 import { anchorOf, 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) {
+export function holds(role, persona) {
+    const anchor = anchorOf(role.sign);
+    if (persona !== undefined) {
+        // A role-named agent is the generic holder and is built by `holds(role)`; one that
+        // declares anything is two agents under one name.
+        if (persona.name === anchor) {
+            throw new Error(`${anchor} is named for the role it holds, so it declares nothing beyond the role: build it with holds(role), or give the persona a name of its own`);
+        }
+        if (!persona.archetype?.trim()) {
+            throw new Error(`persona ${persona.name} declares no archetype of its own`);
+        }
+        const mark = persona.provenance?.mark;
+        if (mark === undefined) {
+            throw new Error(`persona ${persona.name} declares no mark of its own`);
+        }
+        if (mark.emoji === role.provenance.mark.emoji &&
+            mark.hue === role.provenance.mark.hue) {
+            throw new Error(`persona ${persona.name} declares the mark of the ${anchor} role it holds, not a mark of its own`);
+        }
+    }
+    const declared = persona ?? {};
+    const own = persona ?? role;
     const resolved = {
-        name: declared.name,
-        description: declared.description,
-        archetype: declared.archetype,
-        provenance: declared.provenance,
+        name: persona?.name ?? anchor,
+        description: own.description,
+        archetype: own.archetype,
+        provenance: own.provenance,
         // The held role's anchor, on the identity face: forge is blind to the `role`
-        // dimension, so this is the one place the position reaches a harness.
-        holds: anchorOf(role.sign),
+        // dimension, so this is the one place the role reaches a harness.
+        holds: anchor,
         ...(role.dispatches.length > 0
             ? { dispatches: role.dispatches.map((r) => anchorOf(r)) }
             : {}),

package/dist/roles/hold.js.map

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

package/dist/roles/implementer.js

@@ -20,7 +20,7 @@ import { perception as perception_situationAwareness } from '../dimensions/situa
 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
+// this role's decisions were made for it. It needs a unit of work, tools, and the
 // discipline to stay inside the boundary: its unit is built in its own isolated worktree
 // off the plan's line, and while the plan is bound it never commits on main.
 //
@@ -29,15 +29,28 @@ import { limitationDisclosure as limitationDisclosure_transparency } from '../di
 // receives `design`. Its one plan read, `cratylus plan show <unit> --plan <plan>`, and its
 // one plan write, `cratylus plan land …` recording each commit that holds the unit, are
 // stated in the role sign rather than by `plan`, which composes `design`.
+//
+// THE GENERIC HOLDER is `implementer`, and the only agent on the ladder whose write layer
+// is the substrate. It verifies — did I build what the spec said, proven against the
+// spec's own criteria — and it does NOT validate: validation is conformance to a design
+// this role does not hold, and an implementer judging its own conformance is the closed
+// loop the ladder exists to open.
+//
+// It also writes its own landing: the commit that holds the unit is recorded in the
+// unit's history by the implementer, as the commit is made, so the ledger says where the
+// unit stands and the return stays a name.
 export const implementerRole = {
     sign: implementer_role,
+    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it in its own isolated worktree off the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
+    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work in its own isolated worktree off the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
+    provenance: { mark: { emoji: '🔧', hue: 'white' } },
     skills: ['note'],
     // Dispatches no role: it builds its one unit and returns a name.
     dispatches: [],
     vector: {
         formality: plain_formality,
         audienceAdaptation: maintenance_audienceAdaptation,
-        // `limitation-disclosure`, and its channel is a NOTE. What this position could not
+        // `limitation-disclosure`, and its channel is a NOTE. What this role could not
         // establish is owed to the design, and the design takes a delegate's finding as a
         // note; the return is a name with no account, and the unit is judged on the
         // assayer's verdict, never on anything said about the work. An unproven leg left
@@ -45,7 +58,7 @@ export const implementerRole = {
         // without anyone having been told the leg was open.
         transparency: limitationDisclosure_transparency,
         // `mission-command` alone. `handoff` shapes a report that leads with its evidence and
-        // ends on the operator's action items, and this position hands up a name, not a report.
+        // ends on the operator's action items, and this role hands up a name, not a report.
         autonomy: [missionCommand],
         objective: correctness_objective,
         engineeringPrinciples: [
@@ -66,7 +79,7 @@ export const implementerRole = {
         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.
+        // role 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.

package/dist/roles/implementer.js.map

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

package/dist/roles/integrator.js

@@ -9,17 +9,33 @@ import { integrator as integrator_role } from '../dimensions/role/integrator.js'
 import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
 import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
 // THE RUNG THAT MAKES APPROVED WORK WHOLE. It carries no `software-engineering`, and
-// the absence is the same decision as `writes ≠ artifact` in its contract: this position
+// the absence is the same decision as `writes ≠ artifact` in its contract: this role
 // combines and checks, and a holder whose capabilities included building would be one
 // good intention away from repairing a red on the line. It finds the line the planner's
 // bind cut and cuts no branch of its own, and commits the records that line's worktree holds.
 //
 // `deliver`, and it is the plan-side conduct of the loop, the skill that says what
 // arrives here, in what order, and what goes back. Skill routing gives it with `design`,
-// `plan` and `note`, so the position reads the records it commits without being handed
+// `plan` and `note`, so the role reads the records it commits without being handed
 // them.
+//
+// THE GENERIC HOLDER is `integrator`. Nothing in it is idiosyncratic to the agent: which
+// units it takes, the single whole-check, the red that names a unit, and the refusal to
+// repair, judge, decide or move main are all facts about the ROLE.
+//
+// NOT A CI BOT THAT FIXES, and NOT A RELEASE MANAGER THAT PUSHES, and the description
+// says both out loud because a dispatcher will reach for the nearest familiar shape. A CI
+// bot that repairs turns a red into an unjudged green; a release manager that pushes takes
+// the operator's sign-off. Both prohibitions live in the role contract, where a rubric
+// can quote them.
+//
+// It writes whole or broke into the unit's own history before it reports, so the report is
+// a name and the ledger says where the unit stands.
 export const integratorRole = {
     sign: integrator_role,
+    description: 'Use this agent to make approved work whole — it takes each unit whose assay verdict is achieved, combines it with the work already approved on the plan’s integration line, and runs the project’s full check once on the combined tree so no implementer has to. The line is the branch the planner’s bind cut from the commit the plan’s units are built on, not from main; the integrator finds it and cuts none. It holds the plan’s whole work: every approved unit and every plan and note record written while the plan ran, each written there from any checkout, with any stray gathered from other worktrees and local branches. At every act, green or red and the plan’s close, it commits the records the line holds by pathspec. Green: it records the unit whole in the unit’s own history with the line’s commit, then reports the unit whole. Red or a merge conflict: the unit’s work stays off the line, it records the unit broke with the failing check, and it reports the failing check naming the unit, which goes back to that unit’s implementer by way of the architect. Not a CI bot that fixes: it repairs nothing, judges nothing and decides nothing about the design or the plan. Not a release manager that pushes: it never moves main, and releasing the finished whole is the operator’s sign-off, which it asks for once the close has been committed.',
+    archetype: 'Gatekeeper of the whole — work reaches it already judged, and what it adds is the one fact no unit’s own proof can carry: that the approved units still hold together, and that the line holding them lacks nothing. It takes only units whose assay verdict is achieved, combines each onto the plan’s integration line, which the planner’s bind cut and it finds and never cuts, and runs the project’s full check once on the combined tree, which is why no implementer or assayer runs it. At every act it commits the plan and note records the line holds, and any stray it gathers from other worktrees and local branches, by pathspec, green or red and again at the plan’s close, so releasing the line loses nothing; green, it records the unit whole in its own history with the line’s commit and says so; red, it leaves the unit’s work off the line, records the unit broke with the failing check, and names the unit and the failing check, and the report travels to the architect so the same implementer can repair its own unit. Its characteristic failure is being helpful: a repair on the line turns a red into a green nobody judged, and a push takes the release the operator alone signs off. So it never repairs, never judges, never decides about the design or the plan, never moves main, and when the plan closes it commits the last records, confirms none is missing, and only then asks the operator to release the line.',
+    provenance: { mark: { emoji: '🧩', hue: 'orange' } },
     skills: ['deliver'],
     // Dispatches no role: it combines the unit it is given and returns a report.
     dispatches: [],
@@ -28,7 +44,7 @@ export const integratorRole = {
         // commit, acts inside that intent, and answers with a fact. The one decision that
         // is not its own, releasing to main, it asks the operator for.
         autonomy: [missionCommand],
-        // `delivery`: what this position produces is the integrated green whole, and a
+        // `delivery`: what this role produces is the integrated green whole, and a
         // combination it could not check is a delivery that did not happen. The phrase
         // carries the whole objective, so it is cited whole rather than paraphrased.
         objective: delivery_objective,

package/dist/roles/integrator.js.map

@@ -1 +1 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/roles/integrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AAC1H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAGtI,qFAAqF;AACrF,yFAAyF;AACzF,sFAAsF;AACtF,wFAAwF;AACxF,8FAA8F;AAC9F,EAAE;AACF,mFAAmF;AACnF,yFAAyF;AACzF,uFAAuF;AACvF,QAAQ;AAER,MAAM,CAAC,MAAM,cAAc,GAAa;IACtC,IAAI,EAAE,eAAe;IACrB,MAAM,EAAE,CAAC,SAAS,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,EAAE;IACd,MAAM,EAAE;QACN,gFAAgF;QAChF,kFAAkF;QAClF,+DAA+D;QAC/D,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,+EAA+E;QAC/E,+EAA+E;QAC/E,6EAA6E;QAC7E,SAAS,EAAE,kBAAkB;QAC7B,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,oFAAoF;QACpF,qFAAqF;QACrF,YAAY,EAAE;YACZ,gCAAgC;YAChC,+BAA+B;SAChC;QACD,oFAAoF;QACpF,qFAAqF;QACrF,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,iBAAiB,EAAE,uBAAuB;QAC1C,kFAAkF;QAClF,qFAAqF;QACrF,WAAW,EAAE,qBAAqB;QAClC,kFAAkF;QAClF,qCAAqC;QACrC,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/roles/integrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AAC1H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAGtI,qFAAqF;AACrF,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AACxF,8FAA8F;AAC9F,EAAE;AACF,mFAAmF;AACnF,yFAAyF;AACzF,mFAAmF;AACnF,QAAQ;AACR,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,mEAAmE;AACnE,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,2FAA2F;AAC3F,uFAAuF;AACvF,kBAAkB;AAClB,EAAE;AACF,2FAA2F;AAC3F,oDAAoD;AAEpD,MAAM,CAAC,MAAM,cAAc,GAAa;IACtC,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,6zCAA6zC;IAC/zC,SAAS,EACP,s4CAAs4C;IACx4C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;IACpD,MAAM,EAAE,CAAC,SAAS,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,EAAE;IACd,MAAM,EAAE;QACN,gFAAgF;QAChF,kFAAkF;QAClF,+DAA+D;QAC/D,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,2EAA2E;QAC3E,+EAA+E;QAC/E,6EAA6E;QAC7E,SAAS,EAAE,kBAAkB;QAC7B,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,oFAAoF;QACpF,qFAAqF;QACrF,YAAY,EAAE;YACZ,gCAAgC;YAChC,+BAA+B;SAChC;QACD,oFAAoF;QACpF,qFAAqF;QACrF,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,iBAAiB,EAAE,uBAAuB;QAC1C,kFAAkF;QAClF,qFAAqF;QACrF,WAAW,EAAE,qBAAqB;QAClC,kFAAkF;QAClF,qCAAqC;QACrC,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/roles/planner.js

@@ -25,12 +25,20 @@ import { provenanceAttribution as provenanceAttribution_transparency } from '../
 // shards were cut 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
+// `system-design` is absent alongside `software-engineering` — this role neither
 // designs nor builds. What it owns is the plan: the census, the units cut from the
 // shards it is handed, and the plan's records from binding, which cuts the plan's line, to
-// closing. The integrator, not this position, commits the records it writes on the line.
+// closing. The integrator, not this role, commits the records it writes on the line.
+//
+// THE GENERIC HOLDER is `planner`, and it declares nothing: the census, the cut into units,
+// the refusal to redraw a shard, the waves and the plan's records are all facts about the
+// ROLE, and a persona over a different domain would declare its domain and inherit every
+// one of them.
 export const plannerRole = {
     sign: planner_role,
+    description: 'Use this agent to plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: 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 the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
+    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. 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. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
+    provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
     // The role declares one skill, `plan`, and is given plan's composition with it
     // (`design`, `note`), so it reads the shards it plans. `deliver` belongs to the rung
     // ABOVE, which cuts them; the rung BELOW declares none at all, because an
@@ -47,7 +55,7 @@ export const plannerRole = {
         // inferred.
         transparency: provenanceAttribution_transparency,
         autonomy: [missionCommand, handoff_autonomy],
-        // `thoroughness`, not `delivery`: this position ships no artifact a user sees, and
+        // `thoroughness`, not `delivery`: this role ships no artifact a user sees, and
         // its failure mode is an incomplete census rather than a slow one.
         objective: thoroughness_objective,
         engineeringPrinciples: [
@@ -64,7 +72,7 @@ export const plannerRole = {
             researchInvestigation_capabilities,
         ],
         learning: correctionConsolidation_learning,
-        // `comprehension`, where the architect holds `projection`: this position's job is
+        // `comprehension`, where the architect holds `projection`: this role's job is
         // to establish what IS, exhaustively, not to anticipate what follows.
         situationAwareness: comprehension_situationAwareness,
         framing: decompositional_framing,

package/dist/roles/planner.js.map

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

package/dist/rules/repo-preamble.js

@@ -24,7 +24,7 @@ export const repoPreamble = {
     refs: [],
     content: `# AGENTS
 
-**CRITICAL INVARIENT:** You **MUST Read** these documents upon session-start:\\*\\*
+**CRITICAL INVARIANT:** You **MUST Read** these documents upon session-start:
 
 - [\`CANON.md\`](./CANON.md) — **overview and primer**
 - [\`CRATYLISM\`](./packages/canon/src/dimensions/engineering-principles/cratylism.ts) — The First Principle (**LOCKED**)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratylus/canon",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "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": {
@@ -18,11 +18,11 @@
   ],
   "//test": "`test` builds FIRST because `test/runtime-shim.test.ts` drives the shipped `cratylus project` over the repository's own `cratylus.config.ts`, and that config extends `@cratylus/canon` — the PACKAGE, i.e. this package's `dist`. turbo's `test.dependsOn: [^build]` builds this package's DEPENDENCIES, never this package, so a cold clone would run the consumer path against a dist that does not exist.",
   "dependencies": {
-    "@cratylus/schema": "0.8.0"
+    "@cratylus/schema": "0.8.1"
   },
   "devDependencies": {
-    "@cratylus/forge": "0.14.0",
-    "@cratylus/runtime": "0.9.1",
+    "@cratylus/forge": "0.14.1",
+    "@cratylus/runtime": "0.9.2",
     "@cratylus/tooling": "0.0.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",