@sdd-method/maintain-cli 0.8.0 → 0.10.0

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";
@@ -84,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");
@@ -92,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);

package/dist/lib/ci-binding/module.js

@@ -144,8 +144,10 @@ export class MethodValidation {
       if (code !== 0 && !step.advisory) failed++
       lines.push(verdict.padEnd(8) + " exit " + code + "  " + step.id + "  (" + step.title + ")")
       if (code !== 0 || measuredNothing) {
-        const out = (await ran.stdout()) + (await ran.stderr())
-        lines.push(...out.trim().split("\n").slice(-6).map((l) => "           " + l))
+        const out = ((await ran.stdout()) + (await ran.stderr())).trim().split("\n")
+        // Every failure line, then the step's last lines: a long report never hides a finding behind its tail.
+        const failures = out.filter((l) => /^\s*\[FAIL\] /.test(l))
+        lines.push(...[...failures, ...out.slice(-6).filter((l) => !failures.includes(l))].map((l) => "           " + l))
       }
     }
     lines.push(failed === 0 ? "RESULT: PASS" : "RESULT: FAIL (" + failed + " failing step(s))")

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/hooks-seed/entries.js

@@ -1,5 +1,5 @@
 /**
- * Builders for the method-managed hook matchers per ADR 0129 §4.2.
+ * Builders for the method-managed hook matchers per M-ADR 0129 §4.2.
  *
  * Every command carries the METHOD_MANAGED_SENTINEL suffix so the
  * merge path can identify it on refresh. Adopter-added hooks under

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/builder.js

@@ -40,7 +40,7 @@ export async function buildPack(opts) {
             await mkdir(dirname(dest), { recursive: true });
             await copyFile(src, dest);
         }
-        // 3b. Publish transform (ADR 0183/0184) — method-baseline builds only.
+        // 3b. Publish transform (M-ADR 0183/0184) — method-baseline builds only.
         // Produces the point-in-time / producer-agnostic published payload and
         // fails closed on any published-surface leak, before anything is hashed
         // or tarred. Non-Accepted ADRs are dropped from the payload.
@@ -224,7 +224,7 @@ function renderManifest(ctx) {
     lines.push(`source_commit: "${ctx.sourceCommit}"`);
     lines.push(`generated_at_utc: "${generatedAt}"`);
     lines.push(``);
-    lines.push(`# Bundle topology (per ADR 0151 §4)`);
+    lines.push(`# Bundle topology (per M-ADR 0151 §4)`);
     lines.push(`is_forward_base: false`);
     lines.push(`produced_by_adopter: "${sourceRepo}"`);
     if (ctx.seed.forwardBase) {

package/dist/lib/pack/index.js

@@ -34,7 +34,7 @@ export async function runPackBuild(opts, stdout = (s) => process.stdout.write(s)
     stdout(info(`Seed loaded: ${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)"));
     stdout(info(`Managed paths declared: ${seed.managedPaths.length}`));
     // Origin-prefix implies the publish transform: the ADR rename lives inside it,
     // so the flag would be a silent no-op otherwise.

package/dist/lib/pack/leakage.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 export async function checkLeakage(opts) {
     const violations = [];
     // 1. Disjointness with the forward base. Profile-agnostic packs
-    // (no forward_base, ADR 0176 §4.6) compare against an explicitly
+    // (no forward_base, M-ADR 0176 §4.6) compare against an explicitly
     // supplied MANAGED_PATHS.txt when given; with neither declared nor
     // supplied, the forward-base half of the check is skipped (the
     // forbidden-paths half below still runs).

package/dist/lib/pack/publish-transform.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { ORIGIN_PREFIX_SRC, originPrefixForNumber, originPrefixForPath, } from "../adr-origin.js";
 export { originPrefixForNumber };
 /**
- * Publish transform (sdd-method ADR 0183 / 0184). Produces the point-in-time,
+ * Publish transform (sdd-method M-ADR 0183 / 0184). Produces the point-in-time,
  * producer-agnostic *published* form of method markdown by subtraction from the
  * canon, and gates the result with a fail-closed deny-class lint.
  *
@@ -16,7 +16,7 @@ export { originPrefixForNumber };
  * Enabled only for method-baseline builds (BuildOptions.publishTransform);
  * adopter-pack builds are unaffected.
  */
-// Header fields stripped on publish (ADR 0184 — adr-metadata-schema.md).
+// Header fields stripped on publish (M-ADR 0184 — adr-metadata-schema.md).
 const STRIPPED_FIELDS = [
     "Status History",
     "Acceptance Rationale",

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/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.
@@ -14,13 +14,6 @@ const FORWARD_BASE_BUNDLES = new Set([
     "reverse-baseline",
 ]);
 export const REPO_KIND_FILE = ".sdd-repo-kind";
-/**
- * Legacy marker filename from the pre-rebrand era. Read-only fallback during
- * the rebrand transition: `readRepoKind` accepts either filename; `sync`
- * auto-migrates legacy → canonical. New writes always use `REPO_KIND_FILE`.
- * Drop after one minor-version overlap.
- */
-export const LEGACY_REPO_KIND_FILE = ".iteraitive-repo-kind";
 const PROFILE_BY_REPO_KIND = {
     "platform-product": "platform",
     "application-product": "application",
@@ -59,7 +52,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 +66,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.
  */
@@ -103,8 +96,7 @@ export function isBundleName(value) {
     return ALL_BUNDLE_NAMES.has(value);
 }
 export async function readRepoKind(repoRoot) {
-    // Canonical first; fall back to legacy marker during the rebrand transition.
-    for (const filename of [REPO_KIND_FILE, LEGACY_REPO_KIND_FILE]) {
+    for (const filename of [REPO_KIND_FILE]) {
         const path = join(repoRoot, filename);
         let raw;
         try {