@sdd-method/author-cli 0.10.0 → 0.12.0

package/dist/lib/catalogue/manifest-loader.js

@@ -218,6 +218,16 @@ const ManifestSchema = z.object({
     // Shared-library trait (sdd-manifest-schema 1.12.0, M-ADR 0217 §4.4). Profile-agnostic,
     // like `exemplar`; absent is the unmarked norm, no finding.
     shared_library: z.boolean().optional(),
+    // Where this estate's journey behaviour is mastered (sdd-manifest-schema 1.13.0, M-ADR 0229 §4.2, Proposed).
+    // `master` is declared at the root, and journey-impact treats a member naming its platform as inheriting it.
+    // `test_paths` is never inherited: it is relative to this SDD, so an SDD that holds end-to-end files declares
+    // its own block, with the master and its paths. Unknown values fail at load.
+    journeys: z
+        .object({
+        master: z.enum(["test-file", "store"]),
+        test_paths: z.array(z.string()).optional(),
+    })
+        .optional(),
     // Application-product archetype trait (M-ADR 0191, sdd-manifest-schema
     // 1.2.0). RESOLVED enum, not fixed: the loader validates only the slug
     // shape here. Whether the value resolves against the active vocabulary
@@ -378,6 +388,9 @@ export async function loadSddManifest(sddPath, options) {
         ...(parsed.data.packaging !== undefined ? { packaging: parsed.data.packaging } : {}),
         ...(parsed.data.exemplar !== undefined ? { exemplar: parsed.data.exemplar } : {}),
         ...(parsed.data.shared_library !== undefined ? { sharedLibrary: parsed.data.shared_library } : {}),
+        ...(parsed.data.journeys !== undefined
+            ? { journeys: { master: parsed.data.journeys.master, testPaths: parsed.data.journeys.test_paths ?? [] } }
+            : {}),
         ...(parsed.data.application_archetype !== undefined
             ? { applicationArchetype: parsed.data.application_archetype }
             : {}),

package/dist/lib/catalogue/retired-catalogues.js

@@ -0,0 +1,25 @@
+// Catalogues a schema major has retired. A build writes the catalogues the schema declares, so the file of one
+// it no longer declares would otherwise stay on disk beside its replacement, and `catalogue build --check`
+// would report it committed and no longer produced in every estate after the wave. The build and the aggregate
+// remove it from the directory they write, and say so. Only a catalogue named here is removed: a CSV the method
+// never declared is left alone.
+import { rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+/** name -> why it went, and what replaced it. */
+export const RETIRED_CATALOGUES = new Map([
+    ["requirement_status", "retired in catalogue schema 6.0.0: evidence about one revision of a requirement is requirement_assertions (M-ADR 0230 §4.7, Proposed)"],
+]);
+/** Remove each retired catalogue's file from `dir`. Returns the file names removed. */
+export async function removeRetiredCatalogues(dir, findings, label) {
+    const removed = [];
+    for (const [name, why] of RETIRED_CATALOGUES) {
+        const file = join(dir, `${name}.csv`);
+        if (!(await stat(file).then((s) => s.isFile(), () => false)))
+            continue;
+        await rm(file);
+        removed.push(`${name}.csv`);
+        findings.add("convention", `${label}/${name}.csv: removed, ${why}; commit its removal with the rebuilt catalogues`, "warn", `${label}/${name}.csv`);
+    }
+    return removed;
+}
+//# sourceMappingURL=retired-catalogues.js.map

package/dist/lib/catalogue/rubric-coverage-map.yaml

@@ -883,7 +883,7 @@ coverage:
     class: lineage
     impact_flow: none
     reason: derived from the archived changes scored by their own judge
-  requirement_status:
+  requirement_assertions:
     kind: edge
     scoring: derived-edge
     class: realisation
@@ -901,7 +901,7 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
-  requirement_status_value:
+  requirement_assertion_kind:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
@@ -933,3 +933,109 @@ coverage:
     kind: enum
     scoring: not-applicable
     reason: closed vocabulary, not an artefact
+  feature_status:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  journey_requirement:
+    kind: edge
+    scoring: derived-edge
+    class: dependency
+    impact_flow: toward-source
+    reason: derived from end-to-end test tags or journey features' living specs
+  feature_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  journey_requirement_basis:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  entity_attributes:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      entity_id:
+        class: membership
+        impact_flow: toward-target
+  entity_relationships:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      from_entity_id:
+        class: membership
+        impact_flow: toward-target
+      to_entity_id:
+        class: dependency
+        impact_flow: toward-source
+  domain_invariants:
+    kind: entity
+    scoring: scored-at-source
+    instrument: an element of the structural model (M-ADR 0230, Proposed); scored with its domain model by rubrics/domain-architecture-rubric.md
+    relationships:
+      entity_id:
+        class: membership
+        impact_flow: toward-target
+      relationship_id:
+        class: dependency
+        impact_flow: toward-source
+  source_of_truth:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  relationship_end_cardinality:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  domain_invariant_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  requirement_revisions:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a revision of a requirement; scored with its living spec by the behaviour-store check
+    relationships:
+      requirement_id:
+        class: membership
+        impact_flow: toward-target
+      change_id:
+        class: lineage
+        impact_flow: toward-source
+  revision_state:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  change_effects:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a change's effect; scored with the change by the behaviour-store and structural-model checks
+    relationships:
+      change_id:
+        class: membership
+        impact_flow: toward-target
+  change_effect_element_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  adr_governs:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact
+  contract_revisions:
+    kind: entity
+    scoring: scored-at-source
+    instrument: a revision of a contract; scored with its contract by the contract rubrics
+    relationships:
+      contract_id:
+        class: membership
+        impact_flow: toward-target
+      change_id:
+        class: lineage
+        impact_flow: toward-source
+  contract_revision_state:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact

package/dist/lib/catalogue/schema-compat.js

@@ -27,7 +27,7 @@
  * M-ADR 0134 §4.6 (canonical builder + aggregator).
  */
 export const SCHEMA_COMPAT = {
-    catalogue_schema: "^4.0.0",
+    catalogue_schema: "^6.0.0",
     sdd_manifest: "^1.0.0",
     aggregation_manifest: "^1.0.0",
 };

package/dist/lib/catalogue/schema-loader.js

@@ -36,6 +36,7 @@ function normalise(raw) {
             type: c.type,
             nullable: c.nullable ?? false,
             ...(c.description !== undefined ? { description: c.description } : {}),
+            ...((c.source_of_truth ?? def.source_of_truth) !== undefined ? { sourceOfTruth: c.source_of_truth ?? def.source_of_truth } : {}),
         })),
         foreignKeys: (def.foreign_keys ?? []).map((fk) => ({
             column: fk.column,
@@ -45,6 +46,8 @@ function normalise(raw) {
             externalForProfiles: fk.external_for_profiles ?? [],
         })),
         columnEnums: def.column_enums ?? {},
+        ...(def.source_of_truth !== undefined ? { sourceOfTruth: def.source_of_truth } : {}),
+        ...(def.natural_key !== undefined ? { naturalKey: def.natural_key } : {}),
     }));
     const enums = {};
     for (const [name, def] of Object.entries(raw.enums ?? {})) {

package/dist/lib/catalogue/staleness-verdicts.js

@@ -40,6 +40,14 @@
 //   none — already reported by scores-coverage as unknown currency; not
 //       re-reported here.
 //
+// ASSESSED INPUTS (M-ADR 0230 §4.9, Proposed): a review that names its other inputs (`input_paths`) is read with
+//   each of them, once its target is current. An input that moved stales the score, with the input named. So does an
+//   input gone from HEAD, and one the corpus did not hold at the anchor: unlike a missing target, the score can still
+//   be re-reviewed against its target, and a review cannot have read an input that was not there, so both prescribe a
+//   re-review rather than a withdrawal. An input present but uncommitted is UNKNOWN, as the target is, unless another
+//   input moved, which decides it whatever order the inputs are listed in. On the
+//   scored_at basis an input changed after the review stales it.
+//
 // MEMBER TIER ONLY, stated not silent: the aggregate tier reads sibling
 // catalogues whose target files and git histories are not local, so a verdict
 // there would be a guess. Reporting-only (`coverage` class) like the rest of
@@ -163,9 +171,12 @@ export async function runStalenessVerdicts(session, options) {
         };
     }
     const asStr = (v) => v === null || v === undefined ? "" : String(v).trim();
-    const reader = await session.conn.runAndReadAll(`SELECT rubric_id, target_ref, target_path, corpus_ref, scored_at, staleness_basis
+    // input_paths (schema 6.0.0, M-ADR 0230 §4.9, Proposed): a catalogue built before it has no such column, and its
+    // scores are read as naming no other input.
+    const query = (inputs) => `SELECT rubric_id, target_ref, target_path, corpus_ref, scored_at, staleness_basis, ${inputs}
      FROM "quality_scores"
-     WHERE staleness_basis IN ('corpus_ref', 'scored_at');`);
+     WHERE staleness_basis IN ('corpus_ref', 'scored_at');`;
+    const reader = await session.conn.runAndReadAll(query("input_paths")).catch(() => session.conn.runAndReadAll(query("NULL")));
     const rows = reader.getRows();
     const stale = [];
     let current = 0;
@@ -176,10 +187,13 @@ export async function runStalenessVerdicts(session, options) {
     const targetMissing = [];
     const anchorKnown = new Map();
     const renamesByAnchor = new Map();
-    for (const [rubricIdRaw, targetRefRaw, targetPathRaw, corpusRefRaw, scoredAtRaw, basisRaw] of rows) {
+    for (const [rubricIdRaw, targetRefRaw, targetPathRaw, corpusRefRaw, scoredAtRaw, basisRaw, inputPathsRaw] of rows) {
         const rubricId = asStr(rubricIdRaw);
         const targetRef = asStr(targetRefRaw);
         const basis = asStr(basisRaw);
+        // The review's other assessed inputs (M-ADR 0230 §4.9, Proposed): read with the target, so an edit to any of
+        // them makes the score stale as an edit to the target does.
+        const inputs = asStr(inputPathsRaw).split(";").map((x) => x.trim()).filter((x) => x !== "");
         // Counted for BOTH bases, before the branch. The first cut of this counter
         // sat inside the corpus_ref branch only, so it was blind to every
         // scored_at row — and the estate that ASKED for this count has all 18 of
@@ -242,7 +256,42 @@ export async function runStalenessVerdicts(session, options) {
             if (anchorBlob === headBlob) {
                 // Byte-identical to its assessed state — including across a rename,
                 // which is the whole point of testing content instead of touches.
-                current += 1;
+                let moved = null;
+                let unknown = false;
+                for (const input of inputs) {
+                    const now = await blobAt(options.sddRoot, "HEAD", input);
+                    if (now === null && (await existsOnDisk(options.sddRoot, input))) {
+                        unknown = true; // present but uncommitted: no blob to compare, as for the target
+                        continue;
+                    }
+                    let then = await blobAt(options.sddRoot, anchor, input);
+                    if (then === null) {
+                        let renames = renamesByAnchor.get(anchor);
+                        if (renames === undefined) {
+                            renames = await renameMap(options.sddRoot, anchor);
+                            renamesByAnchor.set(anchor, renames);
+                        }
+                        const oldPath = renames.get(input);
+                        if (oldPath !== undefined)
+                            then = await blobAt(options.sddRoot, anchor, oldPath);
+                    }
+                    if (now === null)
+                        moved = `assessed input ${input} no longer exists at HEAD`;
+                    else if (then === null)
+                        moved = `assessed input ${input} was not in the corpus at the anchor`;
+                    else if (then !== now)
+                        moved = `assessed input ${input} CONTENT differs from its state at the anchor`;
+                    if (moved !== null)
+                        break;
+                }
+                // An input that moved decides it, whatever the others are; with none moved, an uncommitted input leaves the
+                // score undecided.
+                if (moved !== null)
+                    stale.push({ rubricId, targetRef, basis: "corpus_ref", detail: moved });
+                else if (unknown)
+                    unknownAnchor += 1;
+                else
+                    current += 1;
             }
             else {
                 stale.push({
@@ -284,10 +333,30 @@ export async function runStalenessVerdicts(session, options) {
                     basis: "scored_at",
                     detail: `target last changed ${last.stdout.slice(0, 10)}, after the review of ${at.slice(0, 10)}`,
                 });
+                continue;
             }
-            else {
-                current += 1;
+            let moved = null;
+            let unknown = false;
+            for (const input of inputs) {
+                const changed = await git(options.sddRoot, ["log", "-1", "--format=%cI", "--", input]);
+                if ((await blobAt(options.sddRoot, "HEAD", input)) === null) {
+                    if (await existsOnDisk(options.sddRoot, input)) {
+                        unknown = true; // present but uncommitted: git has no history for it
+                        continue;
+                    }
+                    moved = `assessed input ${input} no longer exists at HEAD`;
+                }
+                else if (changed.ok && changed.stdout !== "" && Date.parse(changed.stdout) > reviewedMs)
+                    moved = `assessed input ${input} last changed ${changed.stdout.slice(0, 10)}, after the review of ${at.slice(0, 10)}`;
+                if (moved !== null)
+                    break;
             }
+            if (moved !== null)
+                stale.push({ rubricId, targetRef, basis: "scored_at", detail: moved });
+            else if (unknown)
+                unknownAnchor += 1;
+            else
+                current += 1;
         }
     }
     return {

package/dist/lib/intents/migrate.js

@@ -10,6 +10,9 @@
 //              relative path, or a blob URL whose repository is one of the SDDs);
 //   mentioned  a tracked file in an SDD that names the request id, unless the file names many request ids
 //              (an index lists requests; it is not where one went);
+//   titled     a tracked file whose title names the request id (an application's own Epic Brief): it is
+//              about that request whatever else it cites, so it counts even when it names many ids, and it
+//              weighs more than any other evidence in choosing the intent's home;
 //   commit     a commit in an SDD whose message names the id, unless its subject moves, renames, archives or
 //              marks the Ideas and Briefs themselves. When it names at most a few ids (a plan
 //              bundle delivers several), the files it changed that the SDD still owns are evidence too
@@ -17,7 +20,8 @@
 //   plan       a plan file (from --plans) that names the id. A plan says what was planned, not what shipped,
 //              so an id whose only evidence is a plan is flagged for a check that the work landed. A plan
 //              naming at most a few ids also contributes the paths it cites that an SDD owns now (planned).
-// A path that moved since it was cited or committed is followed through the SDD's git renames to where it is
+// With no evidence, an intent goes to the platform among the SDDs (the first one named when none is a
+// platform), and is flagged. A path that moved since it was cited or committed is followed through the SDD's git renames to where it is
 // now. A reviewer's decisions are given back as --home ID=<sdd-id> and --status ID=open|closed.
 // Planning state (status, priority, relations) goes to a tool-neutral work-item import file, never into the
 // intent (M-ADR 0227 §4.3, M-ADR 0035). A dry run writes the report, the import file, the citation table and
@@ -39,6 +43,8 @@ const NOT_OWN = /^(docs\/method\/|catalogues|\.sdd\/|openspec\/schemas\/|content
 const SWEEP = 25;
 /** A commit or plan naming more request ids than this is not evidence for any one of them. */
 const SHARED = 3;
+/** How much a file titled with the id weighs in choosing a home, against one for any other evidence line. */
+const TITLED_WEIGHT = 100;
 const HOUSEKEEPING = /\b(move[sd]?|moving|rename[sd]?|renaming|archive[sd]?|mark(s|ed)?|retire[sd]?|close[sd]?|complete[sd]?)\b.*\b(idea|ideas|idea-map|epic|epics|brief|briefs)\b|\b(idea|ideas|idea-map|epic|epics|brief|briefs)\b.*\b(moved|renamed|archived|marked|retired|closed|completed)\b/i;
 async function walk(dir, accept) {
     const out = [];
@@ -109,7 +115,14 @@ async function loadSdd(dir) {
     catch {
         // not a git repository
     }
-    return { dir, id, repoNames, managed: await managedPaths(dir), renames };
+    let kind = "";
+    try {
+        kind = (await readFile(join(dir, ".sdd-repo-kind"), "utf8")).trim();
+    }
+    catch {
+        // no marker
+    }
+    return { dir, id, repoNames, managed: await managedPaths(dir), renames, kind };
 }
 function readSource(path, text) {
     const doc = parseMarkdown(text);
@@ -306,6 +319,7 @@ export async function migrateIntents(opts) {
     const sdds = await Promise.all(opts.sdds.map((d) => loadSdd(resolve(d))));
     if (sdds.length === 0)
         throw new Error("name at least one SDD (--sdd)");
+    const defaultHome = sdds.find((s) => s.kind === "platform-product") ?? sdds[0];
     // 1. Sources, grouped by request id.
     const byId = new Map();
     const unrecognised = [];
@@ -332,7 +346,7 @@ export async function migrateIntents(opts) {
     const ids = new Set(byId.keys());
     const map = opts.ideaMap ? readIdeaMap(await readFile(opts.ideaMap, "utf8")) : new Map();
     // 2. Evidence.
-    const ev = new Map([...ids].map((i) => [i, { cited: [], mentioned: [], committed: [], planned: [], commits: [], plans: [] }]));
+    const ev = new Map([...ids].map((i) => [i, { cited: [], mentioned: [], titled: [], committed: [], planned: [], commits: [], plans: [] }]));
     const indexFiles = [];
     for (const [id, e] of byId) {
         const text = [e.idea, e.brief].filter(Boolean).map((f) => readFileSyncSafe(f.path)).join("\n");
@@ -357,11 +371,18 @@ export async function migrateIntents(opts) {
             const hits = [...new Set((text.match(ID_TOKEN) ?? []).filter((t) => ids.has(t)))];
             if (hits.length === 0)
                 continue;
+            // A file titled with a request id is about that request, however many others it cites.
+            const title = /^#\s+(.+)$/m.exec(text)?.[1] ?? "";
+            const titled = (title.match(ID_TOKEN) ?? []).filter((t) => ids.has(t));
+            for (const id of titled)
+                ev.get(id).titled.push({ sdd: s.id, path: rel });
             if (hits.length > opts.indexThreshold) {
                 indexFiles.push(`${s.id}: ${rel} (${hits.length} ids)`);
                 continue;
             }
             for (const id of hits) {
+                if (titled.includes(id))
+                    continue;
                 const e = ev.get(id);
                 if (!e.cited.some((c) => c.sdd === s.id && c.path === rel))
                     e.mentioned.push({ sdd: s.id, path: rel });
@@ -442,15 +463,19 @@ export async function migrateIntents(opts) {
         }
         // Mentioned and committed paths already cited are listed once, as cited.
         const has = (l, x) => l.some((c) => c.sdd === x.sdd && c.path === x.path);
-        e.mentioned = e.mentioned.filter((x) => !has(e.cited, x));
-        e.committed = e.committed.filter((x) => !has(e.cited, x) && !has(e.mentioned, x));
-        e.planned = e.planned.filter((x) => !has(e.cited, x) && !has(e.mentioned, x) && !has(e.committed, x));
+        e.titled = e.titled.filter((x) => !has(e.cited, x));
+        e.mentioned = e.mentioned.filter((x) => !has(e.cited, x) && !has(e.titled, x));
+        e.committed = e.committed.filter((x) => !has(e.cited, x) && !has(e.titled, x) && !has(e.mentioned, x));
+        e.planned = e.planned.filter((x) => !has(e.cited, x) && !has(e.titled, x) && !has(e.mentioned, x) && !has(e.committed, x));
         // Home: the SDD most of the evidence is in, unless a reviewer set it.
         const count = new Map();
         for (const x of [...e.cited, ...e.mentioned, ...e.committed, ...e.planned])
             count.set(x.sdd, (count.get(x.sdd) ?? 0) + 1);
+        // A file titled with the id outweighs the rest: an application's own Epic Brief places its request there.
+        for (const x of e.titled)
+            count.set(x.sdd, (count.get(x.sdd) ?? 0) + TITLED_WEIGHT);
         const ranked = [...count.entries()].sort((a, b) => b[1] - a[1]);
-        let home = sdds[0];
+        let home = defaultHome;
         const set = opts.homes?.get(id);
         if (set) {
             const s = sdds.find((x) => x.id === set);
@@ -466,7 +491,7 @@ export async function migrateIntents(opts) {
             if (ranked.length > 1 && ranked[0][1] === ranked[1][1])
                 flag(id, `home ambiguous: ${ranked.map(([s, n]) => `${s} ${n}`).join(", ")}`);
             home = sdds.find((s) => s.id === ranked[0][0]);
-            if (e.cited.length + e.mentioned.length + e.committed.length === 0)
+            if (e.cited.length + e.titled.length + e.mentioned.length + e.committed.length === 0)
                 flag(id, "planned paths only: check that the work landed");
         }
         const classification = (fields("Classification") || "").toLowerCase();
@@ -475,6 +500,7 @@ export async function migrateIntents(opts) {
         const path = `${dir}/${slug(primary.path, id)}`;
         const where = [
             ...e.cited.map((c) => `- \`${c.path}\` (${c.sdd}; cited)`),
+            ...e.titled.map((c) => `- \`${c.path}\` (${c.sdd}; titled)`),
             ...e.mentioned.map((c) => `- \`${c.path}\` (${c.sdd}; mentioned)`),
             ...e.committed.map((c) => `- \`${c.path}\` (${c.sdd}; committed in ${c.sha}${c.with.length ? ` with ${c.with.join(", ")}` : ""})`),
             ...e.planned.map((c) => `- \`${c.path}\` (${c.sdd}; planned in ${c.plan}${c.with.length ? ` with ${c.with.join(", ")}` : ""})`),
@@ -593,7 +619,7 @@ export async function migrateIntents(opts) {
         `Request ids: ${ids.size} (${pairs.filter((p) => p.idea && p.brief).length} with an Idea and an Epic Brief, ${pairs.filter((p) => p.idea && !p.brief).length} with an Idea only, ${pairs.filter((p) => !p.idea && p.brief).length} with a Brief only).`,
         `Work items: ${items.filter((i) => i.status === "closed").length} closed, ${items.filter((i) => i.status === "open").length} open.`,
         `Homes: ${[...homes.entries()].map(([s, n]) => `${s} ${n}`).join(", ")}.`,
-        `Evidence, ids supported by each source: cited ${supported("cited")}, mentioned ${supported("mentioned")}, committed ${supported("committed")}, planned ${supported("planned")}, commit ${supported("commits")}, plan ${supported("plans")}.`,
+        `Evidence, ids supported by each source: cited ${supported("cited")}, titled ${supported("titled")}, mentioned ${supported("mentioned")}, committed ${supported("committed")}, planned ${supported("planned")}, commit ${supported("commits")}, plan ${supported("plans")}.`,
         "",
         `## Flagged (${flags.size})`,
         "",

package/dist/lib/metamodel/tql-subset-parser.js

@@ -174,7 +174,13 @@ export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {
                     throw new ParseError(`${where}: plays needs <relation>:<role>`);
                 if (decl.plays.has(w[1]))
                     throw new ParseError(`${where}: ${lab} plays ${w[1]} twice`);
-                decl.plays.set(w[1], parseAnnotations(w.slice(2), where));
+                const ann = parseAnnotations(w.slice(2), where);
+                // A plays clause's cardinality constrains participation, which the relational projection has no place for:
+                // refused, so a constraint the model gained can never be dropped by the projection with the gate green.
+                if (ann.key || ann.required || ann.multi || ann.optional) {
+                    throw new ParseError(`${where}: ${lab} plays ${w[1]} with a cardinality annotation; participation cardinality cannot be projected onto the catalogue schema, so it is not admitted`);
+                }
+                decl.plays.set(w[1], ann);
             }
             else if (head === "relates") {
                 if (kind !== "relation")
@@ -225,6 +231,16 @@ export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {
 }
 const ROW_RE = /^insert \$m isa ([a-z][a-z0-9-]*), (.*);$/;
 const TOK_RE = /has ([a-z][a-z0-9-]*) ("(?:[^"\\]|\\.)*"|-?\d+|true|false)/y;
+function valueFamily(v) {
+    return typeof v === "boolean" ? "boolean" : typeof v === "number" ? "integer" : "string";
+}
+function attrFamily(valueType) {
+    if (valueType === undefined)
+        return undefined;
+    if (valueType === "long" || valueType === "integer")
+        return "integer";
+    return valueType;
+}
 export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options = {}) {
     const metaTypes = options.metaTypes ?? META_TYPES;
     const rows = new Map();
@@ -268,9 +284,26 @@ export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options
             else
                 throw new ParseError(`${where}: expected ', has ...' at offset ${i}: ${JSON.stringify(body.slice(i, i + 40))}`);
         }
+        const decl = options.types?.entities.get(typ);
+        if (options.types && !decl)
+            throw new ParseError(`${where}: meta type ${typ} is not declared in the type file`);
+        if (decl) {
+            for (const [k, vs] of acc) {
+                const own = decl.owns.get(k);
+                if (!own)
+                    throw new ParseError(`${where}: ${typ} does not own ${k}; an undeclared meta property is refused, not ignored`);
+                if (!own.multi && vs.length > 1)
+                    throw new ParseError(`${where}: ${typ}.${k} is a single value and appears ${vs.length} times; a repeated scalar is refused, not reduced to its first value`);
+                const fam = attrFamily(options.types.attrs.get(k));
+                for (const v of vs) {
+                    if (fam !== undefined && valueFamily(v) !== fam)
+                        throw new ParseError(`${where}: ${typ}.${k} holds ${JSON.stringify(v)}, but ${k} is of value type ${options.types.attrs.get(k)}`);
+                }
+            }
+        }
         const row = {};
         for (const [k, vs] of acc)
-            row[k] = LIST_KEYS.has(k) ? vs : vs[0];
+            row[k] = (decl ? decl.owns.get(k).multi : LIST_KEYS.has(k)) ? vs : vs[0];
         const list = rows.get(typ) ?? [];
         list.push(row);
         rows.set(typ, list);