@sdd-method/author-cli 0.6.0 → 0.8.0

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

@@ -223,8 +223,8 @@ const ManifestSchema = z.object({
     // shape here. Whether the value resolves against the active vocabulary
     // (method ∪ RA-bundle ∪ adopter) is checked in the build step, which has
     // the bundle cache. Absent reads as "unclassified" (with a finding). Named
-    // application_archetype to stay distinct from the ADR 0173 domain archetype
-    // and the ADR 0169 openui archetype.
+    // application_archetype to stay distinct from the M-ADR 0173 domain archetype
+    // and the M-ADR 0169 openui archetype.
     application_archetype: z
         .string()
         .regex(/^[a-z][a-z0-9-]*$/, {
@@ -298,7 +298,7 @@ export async function loadSddManifest(sddPath, options) {
         const code = err.code;
         if (code === "ENOENT") {
             throw new Error(`SDD manifest not found at ${sourcePath}\n\n` +
-                `Every SDD repo MUST declare an .sdd/sdd-manifest.yaml per ADR 0134 §4.6.\n` +
+                `Every SDD repo MUST declare an .sdd/sdd-manifest.yaml per M-ADR 0134 §4.6.\n` +
                 `Schema: docs/method/methods/sdd-manifest-schema.yaml in sdd-method.\n` +
                 `Bootstrap: \`sdd-cli init\` (when migrated to support manifest authoring).`);
         }

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

@@ -23,8 +23,8 @@
  *     release; migration tooling (`sdd-cli migrate <schema> --to <v>`,
  *     planned) covers downgrade paths.
  *
- * See ADR 0132 (catalogue-integrity gate's schema-drift digest hook) +
- * ADR 0134 §4.6 (canonical builder + aggregator).
+ * See M-ADR 0132 (catalogue-integrity gate's schema-drift digest hook) +
+ * M-ADR 0134 §4.6 (canonical builder + aggregator).
  */
 export const SCHEMA_COMPAT = {
     catalogue_schema: "^4.0.0",

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

@@ -1,7 +1,7 @@
 /**
  * Loader for the canonical catalogue-schema.yaml vendored from sdd-method.
  *
- * Per ADR 0134 §4.6 the canonical builder reads the schema rather than
+ * Per M-ADR 0134 §4.6 the canonical builder reads the schema rather than
  * hardcoding column shapes or FK rules. This loader is the only place in
  * the CLI that knows the schema file's location.
  */

package/dist/lib/catalogue/screen-validation-loader.js

@@ -1,7 +1,7 @@
 /**
  * Loader for the optional `.sdd/screen-validation.yaml` config — the
  * adopter-tunable parameters for screen-spec composition-depth validation
- * (ADR 0168 §4.5) and the archetype overlay (ADR 0169 §4.3).
+ * (M-ADR 0168 §4.5) and the archetype overlay (M-ADR 0169 §4.3).
  *
  * Every field is optional and carries a method default; an absent file means
  * "method defaults only" (the vocabulary-free checks all still run). Follows
@@ -13,7 +13,7 @@
  *     decorative_primitives:            # unlocks screen-styling-primitive-as-structure
  *       - Spacer
  *       - Divider
- *     archetype_overlays:               # per-platform overlay (ADR 0169 §4.3)
+ *     archetype_overlays:               # per-platform overlay (M-ADR 0169 §4.3)
  *       web-generic:
  *         strip_prefixes: [Nwc, Nwe]    # render-only: stripped when humanising labels
  *         overrides:

package/dist/lib/catalogue/service-architecture-parser.js

@@ -3,7 +3,7 @@
 // Extracted from builders/services.ts so two callers can share it:
 //   - the per-SDD services builder (buildServices), and
 //   - the aggregator's federated reverse-metadata enrichment pass
-//     (ADR 0163 P2), which reaches member SDDs' arch docs that the
+//     (M-ADR 0163 P2), which reaches member SDDs' arch docs that the
 //     platform-root's own build never sees.
 //
 // The metadata is read faithfully — not inferred — from three blocks:

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

@@ -8,7 +8,7 @@
 // `docs/domains/{domain}/product/{capability}.traceability.yaml`.
 //
 // Schema reference: docs/method/methods/capability-traceability-manifest-template.yaml
-// in sdd-method (per ADR 0047 / capability-spec-template.md).
+// in sdd-method (per M-ADR 0047 / capability-spec-template.md).
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 import { parse as parseYaml } from "yaml";
@@ -47,6 +47,7 @@ export const CONTRACT_LIST_KEYS = [
     "avro",
     "spicedb",
     "graphql",
+    "cli",
 ];
 /**
  * Every contract path a contracts block declares, across all kinds and both
@@ -83,6 +84,8 @@ export async function loadTraceabilityManifests(opts) {
         }
         throw err;
     }
+    // A manifest dropped whole takes its capability's traceability with it, so
+    // each drop below is an error that fails the build (as for repo-configs).
     const manifests = [];
     for (const path of yamlPaths.sort()) {
         const text = await readFile(path, "utf-8");
@@ -91,18 +94,18 @@ export async function loadTraceabilityManifests(opts) {
             raw = parseYaml(text);
         }
         catch (err) {
-            opts.findings.add("convention", `failed to parse YAML at ${relative(opts.sddPath, path)}: ${err.message}`);
+            opts.findings.add("convention", `failed to parse YAML at ${relative(opts.sddPath, path)}: ${err.message} — manifest dropped`, "error", relative(opts.sddPath, path));
             continue;
         }
         if (!raw || typeof raw !== "object") {
-            opts.findings.add("convention", `${relative(opts.sddPath, path)}: not an object — skipped`);
+            opts.findings.add("convention", `${relative(opts.sddPath, path)}: not an object — manifest dropped`, "error", relative(opts.sddPath, path));
             continue;
         }
         const obj = raw;
         const cap = obj["capability"] ?? {};
         const capId = String(cap["id"] ?? "").trim();
         if (capId === "") {
-            opts.findings.add("convention", `${relative(opts.sddPath, path)}: missing capability.id`);
+            opts.findings.add("convention", `${relative(opts.sddPath, path)}: missing capability.id — manifest dropped`, "error", relative(opts.sddPath, path));
             continue;
         }
         const relPath = relative(opts.sddPath, path);
@@ -279,6 +282,7 @@ function extractContracts(raw) {
     const avro = arr("avro");
     const spicedb = arr("spicedb");
     const graphql = arr("graphql");
+    const cli = arr("cli");
     // `provenance` (3.5.0) MUST be extracted here or the builder that reads it
     // sees nothing — this function reconstructs the block key-by-key rather than
     // passing the parsed object through, which is precisely the shape the
@@ -295,6 +299,7 @@ function extractContracts(raw) {
         ...(avro ? { avro } : {}),
         ...(spicedb ? { spicedb } : {}),
         ...(graphql ? { graphql } : {}),
+        ...(cli ? { cli } : {}),
         ...(provenance ? { provenance } : {}),
     };
 }

package/dist/lib/conformance/finding.js

@@ -53,7 +53,7 @@ export function findingRows(results, runDate) {
             observed_not_declared: r.observedNotDeclared.length,
             needs_triage: r.needsTriage,
             run_date: runDate,
-            source_sdd_id: "", // populated by the aggregator per ADR 0134
+            source_sdd_id: "", // populated by the aggregator per M-ADR 0134
             platform_sdd_id: "", // stamped at organisation tier per M-ADR 0208
         };
         lines.push(FINDING_COLUMNS.map((c) => csvCell(row[c])).join(","));

package/dist/lib/conformance/index.js

@@ -17,7 +17,7 @@ function resolveSource(targetRepo, source, codeRoot) {
 }
 const markdownProviderSignals = async (path, spec) => {
     const out = new Set();
-    // `section` (ADR 0180 delta-pilot extension) scopes the scan to one heading block and accepts a plain
+    // `section` (M-ADR 0180 delta-pilot extension) scopes the scan to one heading block and accepts a plain
     // "Field" header, so a check can read ONE entity table inside a multi-table data-model doc (e.g.
     // data-model.mermaid.md "### Collection: orders") without duplicating the field list into a bespoke
     // surface file. With no `section` the behaviour is byte-for-byte the legacy one (whole file, strict
@@ -499,7 +499,7 @@ function printReconcile(chk, r, schemaDir, out) {
     if (!chk.reconcile || r.target !== "binding-vs-reality")
         return;
     const rc = chk.reconcile;
-    out(`\n--- reconcile ${r.id} -> regenerate \`${rc.block}\` in ${rc.binding} (ADR 0181 §2.3) ---\n`);
+    out(`\n--- reconcile ${r.id} -> regenerate \`${rc.block}\` in ${rc.binding} (M-ADR 0181 §2.3) ---\n`);
     out(`# generated from the observed-set (${r.observed} schemas); the binding cannot drift if generated.\n`);
     if (rc.note)
         out(`# NOTE: ${rc.note}\n`);
@@ -513,7 +513,7 @@ function printReconcile(chk, r, schemaDir, out) {
     }
 }
 async function planChecks(opts, stdout) {
-    // Resolution order: explicit --config wins; else the ADR 0181 binding (checks derived from it);
+    // Resolution order: explicit --config wins; else the M-ADR 0181 binding (checks derived from it);
     // else the conventional .sdd/conformance-checks.yaml; else nothing to do.
     if (!opts.config && hasBinding(opts.targetRepo)) {
         const derived = await deriveChecksFromBinding(opts.targetRepo);
@@ -523,7 +523,7 @@ async function planChecks(opts, stdout) {
         ? resolveSource(opts.targetRepo, opts.config, opts.codeRoot)
         : resolve(opts.targetRepo, ".sdd/conformance-checks.yaml");
     if (!existsSync(configPath)) {
-        stdout(`[skip] no spec↔implementation binding (.sdd/implementation-binding.yaml or .sdd/implementation-bindings/, ADR 0181) and no ` +
+        stdout(`[skip] no spec↔implementation binding (.sdd/implementation-binding.yaml or .sdd/implementation-bindings/, M-ADR 0181) and no ` +
             `checks file at ${configPath}\n`);
         return null;
     }
@@ -562,7 +562,7 @@ export async function runConformance(opts, stdout = (line) => process.stdout.wri
         stdout(JSON.stringify({ checks: results, skipped }, null, 2) + "\n");
     }
     else {
-        stdout("Conformance-reverse (advisory; disposition is triage — ADR 0180 §2.3).\n");
+        stdout("Conformance-reverse (advisory; disposition is triage — M-ADR 0180 §2.3).\n");
         for (const r of results) {
             printHuman(r, stdout);
             if (opts.reconcile) {

package/dist/lib/contracts-availability/index.js

@@ -116,7 +116,7 @@ async function collectReferences(repo) {
         const block = m.traceability.contracts;
         if (!block)
             continue;
-        for (const list of [block.openapi, block.proto, block.avro, block.spicedb]) {
+        for (const list of [block.openapi, block.proto, block.avro, block.spicedb, block.graphql, block.cli]) {
             if (!Array.isArray(list))
                 continue;
             for (const entry of list) {
@@ -186,15 +186,21 @@ async function sourceCoordinate(abs) {
         return "unversioned";
     }
 }
-function inferKind(ref) {
+export function inferKind(ref) {
     if (ref.endsWith(".avsc"))
         return "event";
     if (ref.endsWith(".proto"))
         return "rpc";
     if (ref.endsWith(".zed"))
         return "authz";
+    if (/\.graphqls?$/.test(ref))
+        return "graphql";
     if (/openapi/.test(ref) && /\.(ya?ml|json)$/.test(ref))
         return "rest";
+    // A command manifest lives under a `cli/` contracts folder. Tested after rest, so an OpenAPI file in a
+    // repository whose own name ends in -cli stays rest.
+    if (/(^|\/)cli\/.*\.ya?ml$/.test(ref))
+        return "cli";
     return undefined;
 }
 async function readManifest(abs) {

package/dist/lib/generate-briefing/index.js

@@ -6,7 +6,7 @@
  * source of truth).
  *
  * Replaces the v0.3.0 `generate-claude-md` verb whose rich-content
- * output diverges from the ADR 0148 thin-pointer shape.
+ * output diverges from the M-ADR 0148 thin-pointer shape.
  */
 import { access } from "node:fs/promises";
 import { join } from "node:path";
@@ -36,7 +36,7 @@ export async function runGenerateBriefing(opts, stdout = (line) => process.stdou
     // graceful skip downstream.
     const templatesPresent = await fileExists(join(opts.targetDir, BRIEFING_TEMPLATE_ROOT, "agent-instructions.md.hbs"));
     if (!templatesPresent) {
-        stdout(fail(`Briefing templates not found under ${BRIEFING_TEMPLATE_ROOT}/ — sync against a baseline that ships ADR 0148 templates first.`));
+        stdout(fail(`Briefing templates not found under ${BRIEFING_TEMPLATE_ROOT}/ — sync against a baseline that ships M-ADR 0148 templates first.`));
         return { exitCode: 1 };
     }
     const result = await syncBriefingFiles({

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

@@ -0,0 +1,280 @@
+// The documented TypeQL subset — PARSER (M-ADR 0210 §4.2).
+//
+// This module reads the authored form of a fact-based model and nothing else: it knows
+// the subset's grammar and refuses, with a located error, anything outside it. It knows
+// nothing about catalogues, YAML or projections — that is `schema-projection.ts`. The split
+// is deliberate: a store extending the subset extends the parser; the method's projection
+// is one consumer of the parsed model among possible others.
+//
+// Fail-closed (M-ADR 0200 §4.3): a construct the parser does not recognise is a ParseError,
+// never a skip. The five blindnesses measured in the prototype this replaces — `@values`,
+// an `@card` form outside the subset, a role with two players, a value-type/family
+// contradiction, a content change that must be visible — are each refused here or made
+// visible to the projection, and the round-trip gate proves that with mutation controls
+// before every verdict.
+//
+// Grammar (one declaration per line; `#` outside a string literal starts a comment):
+//   define
+//   attribute <label>, value <string|integer|double|boolean|date|datetime>;
+//   entity <label>[, owns <attr> [@key] [@card(1..1)|@card(0..1)|@card(0..)]][, plays <rel>:<role> [...]] ...;
+//   relation <label>[, relates <role> [@card(1..1)|@card(0..1)|@card(0..)]][, owns ...][, plays ...] ...;
+// Meta rows (the second file):
+//   insert $m isa <meta-type>, has <key> <"string"|int|true|false>[, has ...];
+export class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ParseError";
+    }
+}
+export const VALUE_TYPES = new Set(["string", "integer", "double", "boolean", "date", "datetime"]);
+export const META_TYPES = new Set([
+    "schema-meta",
+    "catalogue-meta",
+    "column-meta",
+    "fk-meta",
+    "column-enum-meta",
+    "enum-meta",
+    "enum-value-meta",
+    "enum-value-property",
+    "coverage-meta",
+    "relationship-meta",
+    "vocabulary-meta",
+    "rule-meta",
+]);
+/** Meta keys whose values are lists (repeated `has` on one row). */
+const LIST_KEYS = new Set(["m-external-for-profile", "m-reads"]);
+function unlit(s, where) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            const n = s[i + 1];
+            const map = { n: "\n", t: "\t", '"': '"', "\\": "\\" };
+            const r = map[n];
+            if (r === undefined)
+                throw new ParseError(`${where}: bad escape \\${n}`);
+            out += r;
+            i++;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/** A `#` outside a string literal starts a comment. */
+export function stripComment(line) {
+    let out = "";
+    let q = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '"' && (i === 0 || line[i - 1] !== "\\"))
+            q = !q;
+        if (c === "#" && !q)
+            break;
+        out += c;
+    }
+    return out.trim();
+}
+const CARD_RE = /^@card\((\d+)\.\.(\d*)\)$/;
+function parseAnnotations(tokens, where) {
+    let key = false;
+    let required = false;
+    let multi = false;
+    let optional = false;
+    for (const t of tokens) {
+        if (t === "@key") {
+            key = true;
+        }
+        else if (t.startsWith("@card(")) {
+            const m = CARD_RE.exec(t);
+            if (!m)
+                throw new ParseError(`${where}: unparseable cardinality ${JSON.stringify(t)}`);
+            const lo = m[1];
+            const hi = m[2];
+            if (lo === "1" && hi === "1")
+                required = true;
+            else if (lo === "0" && hi === "")
+                multi = true;
+            else if (lo === "0" && hi === "1")
+                optional = true;
+            else
+                throw new ParseError(`${where}: cardinality ${t} cannot be projected onto the catalogue schema (only @card(1..1), @card(0..1) or @card(0..) are in the subset)`);
+        }
+        else if (t.startsWith("@values")) {
+            throw new ParseError(`${where}: @values(...) is not admitted in this projection — vocabularies bind through column_enums meta rows or a recorded absence (M-ADR 0210 §4.5)`);
+        }
+        else {
+            throw new ParseError(`${where}: unknown token ${JSON.stringify(t)}`);
+        }
+    }
+    return { key, required, multi, optional };
+}
+function splitClauses(body, where) {
+    // refuse before the naive split can be fooled by a comma inside the parenthesis
+    if (body.includes("@values")) {
+        throw new ParseError(`${where}: @values(...) is not admitted in this projection (M-ADR 0210 §4.5)`);
+    }
+    return body.split(",").map((c) => c.trim());
+}
+const ATTR_RE = /^attribute ([a-z][a-z0-9-]*), value ([a-z]+)$/;
+const TYPE_RE = /^(entity|relation) ([a-z][a-z0-9-]*)(?:, (.*))?$/;
+/** Parse the type-system file. `fileLabel` names the file in error locations. */
+export function parseTypes(text, fileLabel = "catalogue-schema.tql", options = {}) {
+    const singlePlayer = options.singlePlayer ?? true;
+    const attrs = new Map();
+    const entities = new Map();
+    const relations = new Map();
+    const seen = new Set();
+    const lines = text.split(/\r?\n/);
+    for (let ln = 1; ln <= lines.length; ln++) {
+        let line = stripComment(lines[ln - 1]);
+        if (line === "" || line === "define")
+            continue;
+        const where = `${fileLabel}:${ln}`;
+        if (!line.endsWith(";"))
+            throw new ParseError(`${where}: declaration must end with ';' — one declaration per line`);
+        line = line.slice(0, -1);
+        const am = ATTR_RE.exec(line);
+        if (am) {
+            const lab = am[1];
+            const vt = am[2];
+            if (!VALUE_TYPES.has(vt))
+                throw new ParseError(`${where}: unknown value type ${JSON.stringify(vt)}`);
+            if (seen.has(lab))
+                throw new ParseError(`${where}: duplicate declaration of ${JSON.stringify(lab)}`);
+            seen.add(lab);
+            attrs.set(lab, vt);
+            continue;
+        }
+        const tm = TYPE_RE.exec(line);
+        if (!tm)
+            throw new ParseError(`${where}: not in the subset: ${JSON.stringify(line.slice(0, 100))}`);
+        const kind = tm[1];
+        const lab = tm[2];
+        const body = tm[3];
+        if (seen.has(lab))
+            throw new ParseError(`${where}: duplicate declaration of ${JSON.stringify(lab)}`);
+        seen.add(lab);
+        const decl = { owns: new Map(), plays: new Map(), relates: new Map() };
+        for (const clause of body !== undefined ? splitClauses(body, where) : []) {
+            const w = clause.split(/\s+/).filter((x) => x !== "");
+            if (w.length === 0)
+                throw new ParseError(`${where}: empty clause`);
+            const head = w[0];
+            if (head === "owns") {
+                if (w.length < 2)
+                    throw new ParseError(`${where}: owns without attribute`);
+                if (decl.owns.has(w[1]))
+                    throw new ParseError(`${where}: ${lab} owns ${w[1]} twice`);
+                decl.owns.set(w[1], parseAnnotations(w.slice(2), where));
+            }
+            else if (head === "plays") {
+                if (w.length < 2 || !w[1].includes(":"))
+                    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));
+            }
+            else if (head === "relates") {
+                if (kind !== "relation")
+                    throw new ParseError(`${where}: only a relation relates`);
+                if (w.length < 2)
+                    throw new ParseError(`${where}: relates without role`);
+                if (decl.relates.has(w[1]))
+                    throw new ParseError(`${where}: ${lab} relates ${w[1]} twice`);
+                decl.relates.set(w[1], parseAnnotations(w.slice(2), where));
+            }
+            else {
+                throw new ParseError(`${where}: unknown clause ${JSON.stringify(head)}`);
+            }
+        }
+        (kind === "entity" ? entities : relations).set(lab, decl);
+    }
+    // every owned attribute must be declared; every role must exist; a role has at most ONE player
+    const playersAll = new Map();
+    for (const [lab, d] of [...entities, ...relations]) {
+        for (const a of d.owns.keys()) {
+            if (!attrs.has(a))
+                throw new ParseError(`${lab} owns undeclared attribute ${JSON.stringify(a)}`);
+        }
+        for (const rr of d.plays.keys()) {
+            const idx = rr.indexOf(":");
+            const rel = rr.slice(0, idx);
+            const role = rr.slice(idx + 1);
+            const r = relations.get(rel);
+            if (!r)
+                throw new ParseError(`${lab} plays role of undeclared relation ${JSON.stringify(rel)}`);
+            if (!r.relates.has(role))
+                throw new ParseError(`${lab} plays undeclared role ${JSON.stringify(rr)}`);
+            const list = playersAll.get(rr) ?? [];
+            list.push(lab);
+            playersAll.set(rr, list);
+        }
+    }
+    const players = new Map();
+    for (const [rr, ps] of playersAll) {
+        if (ps.length > 1 && !singlePlayer)
+            continue;
+        if (ps.length > 1) {
+            throw new ParseError(`role ${rr} has ${ps.length} players (${ps.join(", ")}); the projection can carry exactly one and refuses to pick`);
+        }
+        players.set(rr, ps[0]);
+    }
+    return { attrs, entities, relations, players, playersAll };
+}
+const ROW_RE = /^insert \$m isa ([a-z][a-z0-9-]*), (.*);$/;
+const TOK_RE = /has ([a-z][a-z0-9-]*) ("(?:[^"\\]|\\.)*"|-?\d+|true|false)/y;
+export function parseMeta(text, fileLabel = "catalogue-schema-meta.tql", options = {}) {
+    const metaTypes = options.metaTypes ?? META_TYPES;
+    const rows = new Map();
+    const lines = text.split(/\r?\n/);
+    for (let ln = 1; ln <= lines.length; ln++) {
+        const line = stripComment(lines[ln - 1]);
+        if (line === "")
+            continue;
+        const where = `${fileLabel}:${ln}`;
+        const m = ROW_RE.exec(line);
+        if (!m)
+            throw new ParseError(`${where}: not in the subset: ${JSON.stringify(line.slice(0, 100))}`);
+        const typ = m[1];
+        const body = m[2];
+        if (!metaTypes.has(typ))
+            throw new ParseError(`${where}: unknown meta type ${JSON.stringify(typ)}`);
+        const acc = new Map();
+        let i = 0;
+        for (;;) {
+            TOK_RE.lastIndex = i;
+            const t = TOK_RE.exec(body);
+            if (!t)
+                throw new ParseError(`${where}: meta row body not in the subset at offset ${i}: ${JSON.stringify(body.slice(i, i + 60))}`);
+            const k = t[1];
+            const v = t[2];
+            let val;
+            if (v.startsWith('"'))
+                val = unlit(v.slice(1, -1), where);
+            else if (v === "true" || v === "false")
+                val = v === "true";
+            else
+                val = Number.parseInt(v, 10);
+            const list = acc.get(k) ?? [];
+            list.push(val);
+            acc.set(k, list);
+            i = TOK_RE.lastIndex;
+            if (i === body.length)
+                break;
+            if (body.startsWith(", ", i))
+                i += 2;
+            else
+                throw new ParseError(`${where}: expected ', has ...' at offset ${i}: ${JSON.stringify(body.slice(i, i + 40))}`);
+        }
+        const row = {};
+        for (const [k, vs] of acc)
+            row[k] = LIST_KEYS.has(k) ? vs : vs[0];
+        const list = rows.get(typ) ?? [];
+        list.push(row);
+        rows.set(typ, list);
+    }
+    return rows;
+}
+//# sourceMappingURL=tql-subset-parser.js.map

package/dist/lib/pack/schema.js

@@ -26,7 +26,7 @@ export const PackSeedSchema = z.object({
     scope: z
         .string()
         .regex(/^[a-z0-9-]+$/, "scope must be lower-kebab-case slug"),
-    // Optional per ADR 0176 §4.6: absent = profile-agnostic pack.
+    // Optional per M-ADR 0176 §4.6: absent = profile-agnostic pack.
     forwardBase: z
         .object({
         bundle: z.enum(KNOWN_FORWARD_BASES),
@@ -66,7 +66,7 @@ export const PackSeedSchema = z.object({
         .array(z.string().min(1))
         .min(1, "managed_paths must have at least one entry"),
     forbiddenPaths: z.array(z.string()).optional(),
-    // ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
+    // M-ADR 0176 §4.3: scaffold-source path prefixes; each must cover at
     // least one managed_paths entry (checked in the superRefine below).
     scaffoldSourcePaths: z.array(z.string().min(1)).optional(),
     requiresPack: z

package/dist/lib/pack/seed.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
 /**
- * Adopter pack seed file. Per ADR 0151 + context-pack-seed-schema.yaml.
+ * Adopter pack seed file. Per M-ADR 0151 + context-pack-seed-schema.yaml.
  *
  * Loaded by `sdd-cli pack build` and `sdd-cli pack validate` from
  * `orchestration/distribution/{pack-name}-seed.yaml` in adopter repos.
@@ -120,7 +120,7 @@ async function loadSeedRecursive(absPath, visited) {
     const seed = {
         version: asString(own.version, "version", absPath),
         scope: asString(own.scope, "scope", absPath),
-        // forward_base optional per ADR 0176 §4.6 (profile-agnostic packs omit it)
+        // forward_base optional per M-ADR 0176 §4.6 (profile-agnostic packs omit it)
         ...(own.forward_base && {
             forwardBase: {
                 bundle: asString(own.forward_base.bundle, "forward_base.bundle", absPath),

package/dist/lib/pack/validate.js

@@ -36,7 +36,7 @@ export async function runPackValidate(opts, stdout = (s) => process.stdout.write
     stdout(pass(`Seed valid: ${seed.scope} v${seed.version}`));
     stdout(info(seed.forwardBase
         ? `Forward base: ${seed.forwardBase.bundle} >= ${seed.forwardBase.minimumVersion}`
-        : "Forward base: none (profile-agnostic pack, ADR 0176 §4.6)"));
+        : "Forward base: none (profile-agnostic pack, M-ADR 0176 §4.6)"));
     if (seed.scaffoldSourcePaths) {
         stdout(info(`Scaffold-source prefixes: ${seed.scaffoldSourcePaths.join(", ")}`));
     }

package/dist/lib/plan/read-sdd.js

@@ -10,7 +10,7 @@ import { parseRepoConfigFile } from "../sdd-index/repo-config.js";
  *
  * Repo-config parsing delegates to the shared sdd-index module so the
  * `plan --pilot` path and the MCP dependency-graph tools see the same
- * view. The richer ADR 0110 shape (package/version/stability) is
+ * view. The richer M-ADR 0110 shape (package/version/stability) is
  * flattened back to path-strings here to preserve the legacy
  * `RepoConfig` contract.
  */
@@ -44,7 +44,7 @@ async function readRepoConfigFor(sddRoot, manifestAbsPath) {
         path: manifestAbsPath,
         aggregates: [],
         internalDependencies: [],
-        contracts: { openapi: [], proto: [], avro: [], spicedb: [], graphql: [] },
+        contracts: { openapi: [], proto: [], avro: [], spicedb: [], graphql: [], cli: [] },
     };
     if (!(await fileExists(manifestAbsPath)))
         return empty;
@@ -62,6 +62,7 @@ function legacyShape(node, sourcePath) {
         proto: [],
         avro: [],
         spicedb: [],
+        cli: [],
     };
     for (const ref of node.contracts)
         byKind[ref.kind].push(ref.path);

package/dist/lib/repo-kind.js

@@ -2,7 +2,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * Forward-base bundles set `.sdd-repo-kind` and qualify as the base
- * layer that additive extensions can compose on top of (per ADR 0135).
+ * layer that additive extensions can compose on top of (per M-ADR 0135).
  * The legacy self-contained `reverse-baseline` is retained as a
  * forward base for compat with adopters who haven't migrated to the
  * `reverse-extension-baseline` additive shape yet.
@@ -59,7 +59,7 @@ export function repoKindFromProfile(profile) {
 /**
  * Returns the profile a bundle authoritatively claims, or null for
  * additive bundles that don't claim a profile of their own. Accepts
- * arbitrary strings (adopter pack names per ADR 0151) and returns null
+ * arbitrary strings (adopter pack names per M-ADR 0151) and returns null
  * for any name not in the closed sdd-method bundle set.
  */
 export function profileFromBundleName(name) {
@@ -73,7 +73,7 @@ export function bundleNameFromProfile(profile) {
 /**
  * Forward-base bundles set `.sdd-repo-kind` and qualify as the base
  * layer that additive extensions compose on top of. Additive bundles
- * (sdd-method's `reverse-extension-baseline` and ADR 0151 adopter
+ * (sdd-method's `reverse-extension-baseline` and M-ADR 0151 adopter
  * packs) return false. Accepts arbitrary strings; unknown names return
  * false.
  */