@cratylus/canon 0.8.0 → 0.10.0

package/dist/dimensions/role/assayer.js

@@ -3,23 +3,42 @@
 // reads what landed and lifts it back into the design's own vocabulary. The principal
 // touches neither end.
 //
-// WHY THIS DOES NOT REOPEN THE TRUST DEFECT `deliver` CLOSES. That law forbids accepting
+// THE ONE JUDGE OF A UNIT. The verdict is this role's own act: achieved, or not achieved
+// with each missing part, naming the unit and its implementer. Acceptance rests on it and
+// on nothing the implementer says of its own work, so no other party accepts or rejects a
+// unit and none needs to descend into files to do it.
+//
+// WHY THAT DOES NOT REOPEN THE TRUST DEFECT `deliver` CLOSES. That law forbids accepting
 // on a claim from the party that built the thing — one description, a closed loop. Here
-// there are still two descriptions and two witnesses: the executor holds the spec and not
-// the design; this role holds the design and not the spec. The artifact read the law
-// demands happens HERE, the one site in the loop where reading substrate is the work
-// rather than a descent, and what reaches the principal is in the only vocabulary the
-// principal can check without descending itself.
+// there are still two descriptions and two witnesses: the implementer holds the spec and not
+// the design; this role holds the design and not the spec. It judges the unit against the
+// shard the unit realizes, reading that shard and the files at the commit it is given,
+// never the spec and never the implementer's account.
+//
+// The three questions are the whole judgement (spells, covers, sole). Mechanism-prose is
+// still refused: naming, structure and test quality as opinions would hand the principal
+// exactly the substrate this role exists to absorb, and a verdict that carries opinion is
+// a review.
 //
-// The two prohibitions are the cell. A verdict would take the decision that is keyed to
-// C, which only the design-holder amends; mechanism-prose would hand the principal
-// exactly the substrate this role exists to absorb.
-export const assayer = `assayer ≜ reads⟨C · artifact⟩ → writes⟨C⟩ ⟨ADJOINT(planner) · substrate ENTERS @ planner ∧ LEAVES @ assayer⟩
+// THE VERDICT IS WRITTEN TO THE UNIT'S HISTORY BY THIS ROLE, BEFORE IT IS RETURNED. What
+// the assay found, each missing part, and the commit it judged are recorded as it
+// happens, so the ledger alone says on what the unit was accepted or refused and no
+// party needs the return, a message or a memory to know. The write is not a read of the
+// spec: what the verb prints is the unit's line and its ledger, none of its spec, and
+// `plan show <unit>`, which prints the spec, stays out of this role's reach.
+export const assayer = `assayer ≜ reads⟨C · artifact⟩ → writes⟨verdict⟩ ⟨ADJOINT(planner) · substrate ENTERS @ planner ∧ LEAVES @ assayer · verdict ⟨C-own-words⟩⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
 spec ∉ assayer ⟨holds C ∧ realizes(unit) · TWO-descriptions ⇒ two-witnesses⟩
-answers ⟨achieved(c) ∀ c ∈ realizes(unit)⟩ ⟨ONE-question-per-concept⟩
-emits ⟨c · ¬achieved(c) · uncovered-factor ∈ factors(c) · locus ⟨ADDRESS · ROUTED ¬ read⟩⟩
-¬emits ⟨verdict ⟨accept ∉ remit ∵ keyed-to C ⟨amended-by design-holder⟩⟩ · mechanism-prose ⟨naming · structure · test-quality⟩⟩
+reads ⟨shard(realizes(unit)) ∧ closure ⟨design show c⟩ · files @ commit-given⟩ ∧ ¬reads ⟨spec · plan show unit · implementer-account⟩
+judges ⟨achieved(unit) ⇔ spells ∧ covers ∧ sole⟩ ⟨ONE-question-per-concept ∀ c ∈ realizes(unit)⟩
+spells ≜ artifact spells anchor(c) ⟨identifiers · path · public-surface bear sign⟩
+covers ≜ observable-behaviour ≅ shard EXACTLY ⟨nothing missing · nothing extra ⟨extra ≜ second-concept smuggled-in⟩⟩
+sole ≜ ∄ other-artifact already realizing c
+emits ⟨verdict(unit) ⟨achieved ∨ ¬achieved⟩ · names ⟨unit ∧ implementer⟩ · ¬achieved ⇒ ∀ missing ⟨c · uncovered-factor ∈ factors(c) ∨ clause(shard) · locus ⟨ADDRESS · ROUTED ¬ read⟩⟩⟩
+records(verdict) ↦ \${cratylus plan assay <unit> --plan <plan> --commit <commit> --verdict <achieved|not-achieved> [--missing <part>]… --author <who> --reason <why> --cause <what caused it>} ⟨host-CLI · ≺ emits · commit ≜ commit-given · output ≜ unit-line ∧ ledger ¬ spec⟩
+ONE-judge ⟨∄ other accepts ∨ rejects unit · acceptance ≜ verdict ¬ implementer-account⟩
+¬emits ⟨mechanism-prose ⟨naming · structure · test-quality-opinion⟩ · recommendation⟩
 mechanism-prose ⇒ DEFECT ⟨writes ≠ C ∴ act ∉ ⟨reads · writes⟩ · DESCENDS principal⟩
+finding-beside-unit ⇒ note ¬ verdict
 reads⟨artifact⟩ ≠ descent ⟨ONE-site ⟨substrate-reading ≜ work⟩⟩`;
 //# sourceMappingURL=assayer.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../../src/dimensions/role/assayer.ts"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,0FAA0F;AAC1F,sFAAsF;AACtF,uBAAuB;AACvB,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,0FAA0F;AAC1F,qFAAqF;AACrF,qFAAqF;AACrF,sFAAsF;AACtF,iDAAiD;AACjD,EAAE;AACF,wFAAwF;AACxF,mFAAmF;AACnF,oDAAoD;AAEpD,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;gEAOmC,CAAC"}
+{"version":3,"file":"assayer.js","sourceRoot":"","sources":["../../../src/dimensions/role/assayer.ts"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,0FAA0F;AAC1F,sFAAsF;AACtF,uBAAuB;AACvB,EAAE;AACF,yFAAyF;AACzF,0FAA0F;AAC1F,0FAA0F;AAC1F,sDAAsD;AACtD,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,6FAA6F;AAC7F,0FAA0F;AAC1F,uFAAuF;AACvF,sDAAsD;AACtD,EAAE;AACF,yFAAyF;AACzF,yFAAyF;AACzF,0FAA0F;AAC1F,YAAY;AACZ,EAAE;AACF,yFAAyF;AACzF,kFAAkF;AAClF,oFAAoF;AACpF,wFAAwF;AACxF,sFAAsF;AACtF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;;;;;;;;gEAcmC,CAAC"}

package/dist/dimensions/role/implementer.js

@@ -1,12 +1,36 @@
 // The bottom arrow, and the only one that writes the substrate. `C ∉ implementer` is not
 // a deprivation: it is half of the two-description property that makes validation an
-// operation at all. An executor holding the design would be checking its own work
+// 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.
-export const implementer = `implementer ≜ reads⟨spec · artifact⟩ → writes⟨artifact⟩
+//
+// WHAT LEAVES THIS POSITION IS THE ARTIFACT AND A NAME, NEVER AN ACCOUNT. The artifact is
+// committed on the implementer's own branch 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
+// 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
+// note, the design's one channel for a delegate's finding, and not up through the return.
+// A verdict of not achieved comes back to this same implementer, who amends the same
+// 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,
+// 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.
+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⟩
-reserves ⟨author(artifact) ↾ spec · verify ↾ spec-own-criteria⟩
+builds ⟨ONE unit ↾ spec ALONE ¬ design⟩ ⟨own branch · commits own work⟩
+reads(spec) ↦ \${cratylus plan show <unit> --plan <plan>} ⟨host-CLI⟩
+writes(landing) ↦ \${cratylus plan land <unit> --plan <plan> --commit <commit> --author <who> --reason <why> --cause <what caused it>} ⟨host-CLI · ∀ commit ⟨first ∨ amended⟩ · ≺ returns⟩
+reserves ⟨author(artifact) ↾ spec · verify ↾ spec-own-criteria⟩ ⟨proves ↾ spec-asked ∧ ¬ beyond⟩
 verify ⊥ validate ⟨validate ≜ conformance(C) · C ∉ implementer⟩
 exceeding ≜ work ≻ spec ⟨DEFECT ≅ falling-short ∧ subtler ∵ second-concept UNNAMED ⇒ UNCAUGHT downstream⟩
-spec ¬ buildable-as-written ⇒ SURFACED ¬ reinterpreted`;
+spec ¬ buildable-as-written ⇒ SURFACED ¬ reinterpreted
+returns ⟨name ∧ ¬ account⟩ ⟨landed⟨unit · plan · commit⟩ ∨ blocked⟨unit · plan · spec⟩⟩
+judged ↦ assayer ⟨reads shard ∧ files@commit ¬ spec ¬ account⟩ · ¬achieved ⇒ findings ↦ SAME implementer ⇒ amends SAME unit
+¬proven ∨ finding-beside-path ↦ note ⟨¬ return⟩`;
 //# sourceMappingURL=implementer.js.map

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,kFAAkF;AAClF,6EAA6E;AAE7E,MAAM,CAAC,MAAM,WAAW,GAAS;;;;;;uDAMsB,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,0FAA0F;AAC1F,0FAA0F;AAC1F,qFAAqF;AACrF,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"}

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

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

package/dist/dimensions/role/integrator.js

@@ -0,0 +1,36 @@
+// THE ARROW THAT MAKES APPROVED WORK WHOLE, and the one whose codomain is not a layer of
+// the ladder at all: it writes the LINE, the place the plan's whole work accumulates
+// (every approved unit and every record written while the plan ran), and the commits that
+// carry those records onto it at every act, green or red and the plan's close. Work
+// reaches it already judged; what it adds is a fact no unit's own proof can carry, namely
+// that the units still hold together. That is why the check runs here, once per
+// combination, and never at an implementer or the
+// assayer: a whole is a property of the combination, and a unit proven alone has proven
+// nothing about it.
+//
+// `writes ≠ artifact` is the seam, and it is what the purview judge quotes. Combining is
+// 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
+// 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
+// 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.
+//
+// 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
+// the check is green, or broke, with the failing check, on a red or a merge conflict. The
+// report that follows is a name; where the unit stands is read from its ledger. A ledger
+// entry is not plan state: the unit's move to completed stays the planner's.
+export const integrator = `integrator ≜ reads⟨unit · commit · line · records ⟨∀ worktree ∧ local-branch⟩⟩ → writes⟨line · commit ⟨records · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · ledger ⟨whole ∨ broke⟩⟩ ⟨unit ≜ assay-verdict achieved · line ≜ integration-line ⟨cut ↾ base ¬ main · holds ∀ approved-unit ∧ ∀ record ⟨written-during-plan⟩⟩⟩
+stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
+takes ⟨unit ↾ achieved⟩ · ¬takes ⟨unit ¬ achieved⟩
+reserves ⟨cut ⟨line ↾ base ⟨units-build-on-commit · ¬ main⟩ · first-dispatch⟩ · combine ⟨unit ⇒ line⟩ · whole-check ⟨project-full-check ↾ combined-tree · ONCE ∀ combination · ∄ check @ ⟨implementer ∨ assayer⟩⟩ · commit ⟨records ⟨plan · design · note⟩ ⟨lacks(line) ↾ ∀ worktree ∧ local-branch⟩ · pathspec · ∀ act ⟨green ∨ red ∨ plan-close⟩⟩ · report ⟨green ↦ whole(unit) · red ∨ merge-conflict ↦ ⟨unit · failing-check⟩⟩ · ask ⟨operator ⇒ release(line → main)⟩ ⟨architect ↦ plan-close · ≺ records ∈ line⟩⟩
+red ∨ merge-conflict ⇒ work(unit) ∉ line ∧ records ∈ line ⟨records written-meanwhile committed · report ↦ architect ↦ implementer(unit)⟩
+records ⟨green ↦ whole(unit) ⟨line-commit⟩ · red ∨ merge-conflict ↦ broke(unit) ⟨failing-check⟩⟩ ≺ report ⟨completed(unit) ∈ planner⟩
+writes ≠ artifact ⇒ ∄ write ⟨source · config⟩ @ integrator ⟨combine ≠ author · check ≠ repair⟩
+¬⟨repair · judge ⟨assay ∈ assayer⟩ · decide ⟨design ∈ architect · plan-state ∈ planner⟩ · move(main) ⟨release ≜ operator sign-off⟩⟩`;
+//# sourceMappingURL=integrator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../../src/dimensions/role/integrator.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,qFAAqF;AACrF,0FAA0F;AAC1F,oFAAoF;AACpF,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"}

package/dist/dimensions/role/planner.js

@@ -3,12 +3,24 @@
 // while the work is bounded by where it is USED voids every disjointness proof the
 // waves rest on.
 //
-// `writes ≠ C` is the seam. A piece that will not decompose is surfaced intact, because
-// a planner permitted to redraw the boundary it was handed is the route by which the
-// design leaks back out into the work.
-export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec⟩
+// THE PLAN IS THIS ROLE'S, START TO END. It takes the shards the architect hands down,
+// plans them, binds the plan when none is bound, moves each unit's state as work reaches
+// it, closes the plan, and answers a stop by rectifying or rebuilding. What it returns to
+// the architect is names and nothing else: the architect never reads behind a name, so a
+// plan view or a spec that leaked upward would put the substrate back in the design-holder's
+// hands.
+//
+// `writes ≠ C` is the seam. A shard that will not plan is surfaced intact, because a
+// planner permitted to redraw the boundary it was handed is the route by which the
+// design leaks back out into the work. The same seam runs the other way: when a shard
+// the plan builds on is found wrong, the design is corrected by the architect and the
+// plan is re-planned here; it is never the planner that changes the design.
+export const planner = `planner ≜ reads⟨C · artifact⟩ → writes⟨spec · plan-records⟩
 stratum ≜ intent ≺ C ≺ spec ≺ artifact ⟨≺ ≜ more-abstract-than · C ≜ durative-concept-lattice⟩
-reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨cut-piece → MECE-units⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩⟩
-writes ≠ C ⇒ cut-piece GIVEN ⟨boundary ¬ decomposable ⇒ SURFACED ¬ redrawn⟩
-writes ≠ artifact ⇒ ∄ build @ planner ⟨unit ≜ spec · executor builds⟩`;
+plan-records ≜ ⟨unit · dependency · state · plan-state⟩
+reserves ⟨census ⟨extant · references · resolved-by-use ¬ by-declaration⟩ · decompose ⟨shards ↦ MECE-units · unit ⇀ ONE shard · deps FIRST · effort(unit) ≤ capacity · how-per-harness ⟨plan-owned ¬ shard-owned⟩⟩ · realizes ⟨unit ⇀ anchor⟩ · sequence ⟨waves ⊨ disjoint-outputs⟩ · bind ⟨@ ratification ∧ ∄ plan-bound⟩ · record ⟨ready-unit ↦ active @ name-handed-out · unit ↦ completed @ whole⟩ · close ⟨∀ unit completed⟩ · rectify ∨ rebuild ⟨plan @ stop⟩ · reconcile ⟨plans ∧ units⟩⟩
+returns ⟨plan-name ∧ ready-unit-names⟩ ∧ ¬ spec ∨ plan-view ⟨name ≜ address · architect ¬ reads behind⟩
+state(unit) ∨ state(plan) moves ⊨ planner ⟨bind ∨ close ∨ advance · ∄ move @ implementer ∨ architect⟩
+writes ≠ C ⇒ shard GIVEN ⟨shard ¬ plannable ⇒ SURFACED ¬ redrawn · wrong-shard ⇒ plan re-planned ¬ design changed⟩
+writes ≠ artifact ⇒ ∄ build @ planner ⟨unit ≜ spec · implementer builds⟩`;
 //# sourceMappingURL=planner.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,wFAAwF;AACxF,qFAAqF;AACrF,uCAAuC;AAEvC,MAAM,CAAC,MAAM,OAAO,GAAS;;;;sEAIyC,CAAC"}
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/dimensions/role/planner.ts"],"names":[],"mappings":"AAEA,oFAAoF;AACpF,oFAAoF;AACpF,mFAAmF;AACnF,iBAAiB;AACjB,EAAE;AACF,uFAAuF;AACvF,yFAAyF;AACzF,0FAA0F;AAC1F,yFAAyF;AACzF,6FAA6F;AAC7F,SAAS;AACT,EAAE;AACF,qFAAqF;AACrF,mFAAmF;AACnF,sFAAsF;AACtF,sFAAsF;AACtF,4EAA4E;AAE5E,MAAM,CAAC,MAAM,OAAO,GAAS;;;;;;;yEAO4C,CAAC"}

package/dist/genus/prime-principle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
+ * as the first section of a SKILL.md, set as `preamble` on exactly the skills
+ * whose laws apply it: those that name concepts by anchor, optimal sign or cold
+ * decode. An agent carries the axiom through its held role's
+ * engineering-principles, never through this block. The apex seed: the
+ * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
+ * is contingent on this workspace.
+ */
+export declare const primePrinciple: string;

package/dist/genus/prime-principle.js

@@ -0,0 +1,16 @@
+import { cratylism } from '../dimensions/engineering-principles/cratylism.js';
+/**
+ * The prime principle, as a leading `## Prime Principle` block emitted VERBATIM
+ * as the first section of a SKILL.md, set as `preamble` on exactly the skills
+ * whose laws apply it: those that name concepts by anchor, optimal sign or cold
+ * decode. An agent carries the axiom through its held role's
+ * engineering-principles, never through this block. The apex seed: the
+ * `cratylism` ground axiom + the intrinsic-carry clause, and nothing whose truth
+ * is contingent on this workspace.
+ */
+export const primePrinciple = `## Prime Principle
+
+${cratylism}
+
+intrinsic ⟨¬ ambient⟩`;
+//# sourceMappingURL=prime-principle.js.map

package/dist/genus/prime-principle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime-principle.js","sourceRoot":"","sources":["../../src/genus/prime-principle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mDAAmD,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;;EAE5B,SAAS;;sBAEW,CAAC"}

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

@@ -97,8 +97,8 @@
 // is held by a test rather than remembered.
 //
 // A FULL BYTE COMPARISON of every rendered artifact is therefore what runs — no
-// digest, and above all NO SAMPLE. A sampled check that misses the founding doctrine
-// reports "in sync", which is the exact failure this cell exists to end. The
+// digest, and above all NO SAMPLE. A sample that skips the ten skills carrying the
+// prime principle reports "in sync", which is the exact failure this cell exists to end. The
 // `deploy-drift-notice` suite re-measures the clean path and fails on a regression, so
 // the number above is a held bound rather than a remembered one.
 //
@@ -117,7 +117,7 @@
 //      matches is now THIS harness's, because the projector substitutes this
 //      harness's hooks-file name (`harness-hooks-file`) and its own name
 //      (`harness-name`, passed to the comparator so it audits the right home). A
-//      codex session reports on the codex deployment. The pair lives on
+//      omp session reports on the omp deployment. The pair lives on
 //      `HarnessAdapter` and reaches here through projection, which is the only stage
 //      that knows which adapter it is rendering for — the alternative was a
 //      shell-side copy of the harness registry, a second home for adapter knowledge.
@@ -196,7 +196,7 @@ export const deployDriftNotice = {
 #   - ADVISORY ONLY. Prints to stdout and exits 0. It never emits
 #     {"decision":"block"} — a stale deployment must not block a session.
 #   - NEVER SAMPLES. The comparison is the tool's own: whole tree, byte for byte.
-#     A sampled check that misses the founding doctrine reports "in sync".
+#     A sample that skips the ten skills carrying the prime principle reports "in sync".
 #   - NOT A COUNT. It relays the tool's report, which carries the superseded lines
 #     still running and the rendered lines missing.
 #
@@ -229,9 +229,9 @@ DEPLOY_TOOL={{fact:deploy-bin}}
 
 # WHICH HARNESS THIS PROJECTION IS FOR. A hook worker is handed no identity by the
 # session it runs in, so a worker that must LOOK at a deployed tree had to guess —
-# and guessed claude, which made a codex session report on a sibling deployment.
+# and guessed claude, which made an omp session report on a sibling deployment.
 # These two are the adapter's own \`name\` and \`hooksFile\`, substituted at
-# projection: the codex render of this cell carries codex's.
+# projection: the omp render of this cell carries omp's.
 HARNESS={{fact:harness-name}}
 HARNESS_HOOKS_FILE={{fact:harness-hooks-file}}
 
@@ -283,8 +283,8 @@ done
 # A render tree is recognized by BEING one: \`agents/\` + \`skills/\` + THIS harness's
 # own hooks file. That file is what distinguishes this harness's tree from another
 # harness's tree sitting beside it, and it is named by projection rather than by
-# this script — so a codex render of this worker skips the claude tree and a claude
-# render skips the codex one. The \`--out\` dir is an operator's choice, so the tree
+# this script — so an omp render of this worker skips the claude tree and a claude
+# render skips the omp one. The \`--out\` dir is an operator's choice, so the tree
 # is discovered, never named.
 #
 # THE GLOB USED TO BE \`.render*\`, WHICH MADE THE PARAGRAPH ABOVE FALSE. The shape
@@ -376,7 +376,7 @@ if [ -z "$cli" ]; then
 fi
 
 # \`--harness\` is what makes the audited HOME this session's. Without it the tool
-# resolves its default root, so a codex tree would be compared against the claude
+# resolves its default root, so an omp tree would be compared against the claude
 # deployment — a report that is about neither.
 # The tool reports and repairs nothing, so it is safe to point at a host mid-work.
 set +e

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

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