@ogygie/core 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Ogygie framework core: manifest/spec/error schemas, generic tenancy and gate tooling. Ships TypeScript sources — Ogygie products run tsx/vitest by construction (D1).",
   "license": "MIT",
   "type": "module",

package/src/manifest.schema.test.ts

@@ -349,3 +349,27 @@ describe("manifest — bloc vocabulary (spec product-vocabulary-gate B2)", () =>
     expect(issue?.path.join(".")).toBe("vocabulary.entries.1.canonical");
   });
 });
+
+describe("manifest — apps vendored (spec product-vocabulary-gate B3, v3)", () => {
+  function manifestWithApp(app: Record<string, unknown>) {
+    return {
+      version: 1,
+      product: { name: "acme", description: "SaaS générique servant de fixture aux tests du manifeste." },
+      apps: [{ name: "tooling", path: "packages/tooling", type: "front", entryPoint: "packages/tooling/src/main.tsx", ...app }],
+      features: [],
+      conventions: { agentsMd: "AGENTS.md", failuresMd: "FAILURES.md", specsFolder: "specs/" },
+    };
+  }
+
+  it("une app déclarée vendored: true est acceptée", () => {
+    expect(OgygieManifestSchema.safeParse(manifestWithApp({ vendored: true })).success).toBe(true);
+  });
+
+  it("une app sans le champ reste la norme (le produit maintient son code)", () => {
+    expect(OgygieManifestSchema.safeParse(manifestWithApp({})).success).toBe(true);
+  });
+
+  it("MUTATION : `vendored: false` est refusé — pas de troisième état", () => {
+    expect(OgygieManifestSchema.safeParse(manifestWithApp({ vendored: false })).success).toBe(false);
+  });
+});

package/src/manifest.schema.ts

@@ -159,6 +159,19 @@ export const OgygieManifestSchema = z.object({
       path: z.string(),
       type: z.enum(["api", "front", "gateway"]),
       entryPoint: z.string(),
+      /**
+       * Code the product HOSTS without maintaining it — imported as-is from
+       * elsewhere, the framework's own dev tooling being the typical case.
+       * A vendored app is skipped by the vocabulary gate: a product's business
+       * vocabulary has no claim over code it will never rename.
+       *
+       * A literal `true`, like `shared` on a table: an app is either vendored
+       * (and says so) or the product's own (and stays silent) — no third
+       * state. The derogation is declared here, machine-readably, and the gate
+       * ANNOUNCES it on every run — one that stops being visible is one that
+       * gets forgotten.
+       */
+      vendored: z.literal(true).optional(),
     }),
   ),
   features: z.array(FeatureManifestSchema),

package/src/vocabulary-audit.test.ts

@@ -121,9 +121,25 @@ describe("auditProductVocabulary — B4 : la pureté des fichiers gouvernés", (
     const violations = auditProductVocabulary({
       vocabulary: VOCABULARY,
       sourceFiles: [],
-      governedFiles: [{ path: "tsconfig.base.json", content: "// tuned for the gizmo pipeline" }],
+      governedFiles: [{ path: "tsconfig.base.json", content: "// tuned for the gadget pipeline" }],
     });
-    expect(violations.map((violation) => violation.match.root)).toEqual(["gizmo"]);
+    expect(violations.map((violation) => violation.match.root)).toEqual(["gadget"]);
+  });
+
+  it("un ALIAS interdit dans un fichier gouverné ne déclenche RIEN (v2)", () => {
+    // An alias is by definition a word the product does NOT use, so finding it
+    // in a generic file proves no contamination — while the framework's own
+    // neutral domain and plain computing English produce such collisions in
+    // bulk (eight false positives out of eighteen on the first real migration).
+    expect(
+      auditProductVocabulary({
+        vocabulary: VOCABULARY,
+        sourceFiles: [],
+        governedFiles: [
+          { path: "AGENTS.md", content: "const widgetId = 1; // gizmo everywhere" },
+        ],
+      }),
+    ).toEqual([]);
   });
 
   it("un fichier gouverné strictement générique passe", () => {

package/src/vocabulary-audit.ts

@@ -8,10 +8,17 @@
  * - PRODUCT SOURCE (B3): only forbidden ALIASES are hunted, and only in the
  *   machine identifiers — comments are blanked out first. The business prose
  *   of the project keeps its own words; the code has one term per concept.
- * - GOVERNED FILES (B4): EVERY declared root is hunted — canonical terms
- *   included — in the RAW text, comments and all. A governed file is identical
- *   in every Ogygie project, so it may know no product's domain at all, not
- *   even in a comment. That is the framework/product boundary made mechanical.
+ * - GOVERNED FILES (B4): the CANONICAL terms are hunted in the RAW text,
+ *   comments and all. A governed file is identical in every Ogygie project, so
+ *   it may know no product's domain at all, not even in a comment. That is the
+ *   framework/product boundary made mechanical.
+ *   Forbidden aliases are deliberately NOT hunted there (spec v2): an alias is
+ *   by definition a word the product does NOT use, so finding one in a generic
+ *   file proves no contamination — while the framework's own neutral domain
+ *   (`orders`, `customerId`) and plain computing English (`level`, `register`)
+ *   collide with it in bulk. Eight false positives out of eighteen on the first
+ *   real migration, and a gate whose verdicts one learns to ignore protects
+ *   nothing.
  *
  * The filesystem is injected (files come in as text), so the whole judgement
  * is a pure function proven in memory with its mutations.
@@ -49,7 +56,11 @@ export interface VocabularyAuditInput {
   readonly governedFiles: readonly ScannedFile[];
 }
 
-/** Every root the vocabulary declares: canonical terms AND forbidden aliases. */
+/**
+ * Every root the vocabulary declares: canonical terms AND forbidden aliases.
+ * Kept for callers that need the full list; the governed-file rule uses the
+ * canonical terms alone (see above).
+ */
 export function vocabularyRootsOf(vocabulary: ProductVocabulary): readonly string[] {
   return vocabulary.entries.flatMap((entry) => [entry.canonical, ...entry.forbiddenAliases]);
 }
@@ -71,7 +82,7 @@ export function auditProductVocabulary(
 
   const canonicalOfAlias = canonicalByAlias(vocabulary);
   const forbiddenAliases = [...canonicalOfAlias.keys()];
-  const everyRoot = vocabularyRootsOf(vocabulary);
+  const canonicalTerms = vocabulary.entries.map((entry) => entry.canonical);
   const violations: VocabularyViolation[] = [];
 
   for (const file of input.sourceFiles) {
@@ -86,7 +97,7 @@ export function auditProductVocabulary(
   }
 
   for (const file of input.governedFiles) {
-    for (const match of findProductVocabulary(file.content, everyRoot)) {
+    for (const match of findProductVocabulary(file.content, canonicalTerms)) {
       violations.push({
         kind: "GOVERNED_FILE",
         filePath: file.path,