@sdd-method/maintain-cli 0.1.0 → 0.2.0

package/dist/lib/sync/index.js

@@ -11,12 +11,11 @@ import { cacheBundle, ensureCacheGitignored, splitConsumptionModes, } from "./bu
 import { PROTECTED_PREFIXES, allPristine, classifyConflicts, computeRemovals, detectShadowCollisions, digestManagedPaths, findConflicts, findMissingPayloadFiles, findProtectedPaths, } from "./diff.js";
 import { applyAdrRenames, findStrandedCitations, planAdrTransitions, } from "./adr-transitions.js";
 import { syncMethodManagedSettings } from "./settings-merge.js";
-import { syncMethodManagedCopilotHooks } from "./copilot-hooks-merge.js";
 import { syncBriefingFiles } from "./briefing-merge.js";
 import { DEFAULT_AGENT_HARNESS } from "../agent-harness.js";
 import { BLOCK_BEGIN, BLOCK_END } from "../init/ci-workflow.js";
 import { blockSha256, CI_BINDINGS, DEFAULT_CI_BINDING, isCiBinding, parseCiRunner, syncCiBinding, } from "../ci-binding/index.js";
-import { BRIEFING_TEMPLATE_ROOT, WRAPPER_BLOCK_BEGIN, WRAPPER_BLOCK_END, harnessWrapperOutputPath, } from "../briefing/index.js";
+import { BRIEFING_TEMPLATE_ROOT, WRAPPER_BLOCK_BEGIN, WRAPPER_BLOCK_END, briefingWrappers, } from "../briefing/index.js";
 const SECTION_RULE = "═".repeat(59);
 /**
  * Report the pristine/edited/unclassifiable split for a conflict set.
@@ -332,32 +331,15 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
             if (incomingIsForward && !opts.allowOverwrite && !migrateFrom) {
                 const preflightProfile = profileFromBundleName(incomingBundleName);
                 if (preflightProfile) {
-                    if (opts.agentHarness === "github-copilot-cli") {
-                        const probe = await syncMethodManagedCopilotHooks({
-                            targetRepo: opts.targetRepo,
-                            allowOverwrite: false,
-                            checkOnly: true,
-                        });
-                        if (probe.refused) {
-                            failures.push(`.github/hooks/*.json has adopter-modified method entries (${probe.driftedRefused.join(", ")}). Re-run with --allow-overwrite to rewrite them.`);
-                        }
-                    }
-                    else {
+                    {
                         const probe = await syncMethodManagedSettings({
                             targetRepo: opts.targetRepo,
-                            profile: preflightProfile,
                             allowOverwrite: false,
                             checkOnly: true,
-                            hadPreviousSync: prevLock !== null,
                             ...(opts.agentHarness ? { agentHarness: opts.agentHarness } : {}),
                         });
                         if (probe.refused) {
-                            const conflicts = [];
-                            if (probe.drifted.length > 0)
-                                conflicts.push(`mcpServers: ${probe.drifted.join(", ")}`);
-                            if (probe.hooksDrifted.length > 0)
-                                conflicts.push(`hooks: ${probe.hooksDrifted.join(", ")}`);
-                            failures.push(`.claude/settings.json has adopter-modified method entries (${conflicts.join("; ")}). Re-run with --allow-overwrite to rewrite them.`);
+                            failures.push(`.claude/settings.json has adopter-modified method entries (hooks: ${probe.hooksDrifted.join(", ")}). Re-run with --allow-overwrite to rewrite them.`);
                         }
                     }
                     // The CI host wrapper and the Method Validation module (M-ADR 0219): the same check the
@@ -377,13 +359,18 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
                     // templates; pre-ADR-0148 baselines skip the briefing pass entirely.
                     const shipsBriefing = bundle.managedPaths.some((p) => p.startsWith(`${BRIEFING_TEMPLATE_ROOT}/`));
                     if (shipsBriefing) {
-                        const wrapperRel = harnessWrapperOutputPath(opts.agentHarness ?? DEFAULT_AGENT_HARNESS);
-                        const preflightWrapper = await tryReadFile(join(opts.targetRepo, wrapperRel));
-                        if (preflightWrapper !== null &&
-                            preflightWrapper !== "" &&
-                            !(preflightWrapper.includes(WRAPPER_BLOCK_BEGIN) &&
-                                preflightWrapper.includes(WRAPPER_BLOCK_END))) {
-                            failures.push(`${wrapperRel} has adopter edits outside the method-managed markers. Re-run with --allow-overwrite to replace the file.`);
+                        // Every wrapper the bundle ships a template for: CLAUDE.md and, from M-ADR 0220, the
+                        // AGENTS.md pointer. An unmarked file is the adopter's and refuses.
+                        for (const w of briefingWrappers(opts.agentHarness ?? DEFAULT_AGENT_HARNESS)) {
+                            if (!bundle.managedPaths.includes(`${BRIEFING_TEMPLATE_ROOT}/${w.templateRel}`))
+                                continue;
+                            const preflightWrapper = await tryReadFile(join(opts.targetRepo, w.outputRel));
+                            if (preflightWrapper !== null &&
+                                preflightWrapper !== "" &&
+                                !(preflightWrapper.includes(WRAPPER_BLOCK_BEGIN) &&
+                                    preflightWrapper.includes(WRAPPER_BLOCK_END))) {
+                                failures.push(`${w.outputRel} has adopter edits outside the method-managed markers. Re-run with --allow-overwrite to replace the file.`);
+                            }
                         }
                     }
                 }
@@ -508,58 +495,21 @@ export async function runSync(opts, stdout = (line) => process.stdout.write(line
         }
         const repoKind = repoKindFromProfile(profile);
         await writeRepoKind(opts.targetRepo, repoKind);
-        // Harness-aware merge of agent-harness wiring per ADR 0141 §4.6.
-        // claude-code keeps the .claude/settings.json path (MCP + Claude
-        // hooks). github-copilot-cli writes .github/hooks/*.json instead;
-        // its MCP wiring lands separately under ADR 0150 Phase 3.
-        if (opts.agentHarness === "github-copilot-cli") {
-            const copilotResult = await syncMethodManagedCopilotHooks({
-                targetRepo: opts.targetRepo,
-                allowOverwrite: opts.allowOverwrite || migrateFrom !== null,
-            });
-            if (copilotResult.refused) {
-                stdout(fail(`.github/hooks/*.json has adopter-modified method entries (${copilotResult.driftedRefused.join(", ")}). Re-run with --allow-overwrite to rewrite them.`));
-                return { exitCode: 1 };
-            }
-            const written = copilotResult.files.filter((f) => f.wrote);
-            if (written.length > 0) {
-                stdout(info(`Refreshed ${written.map((f) => f.relPath).join(", ")}.`));
-            }
-        }
-        else {
+        // The harness wiring: .claude/settings.json, the one supported harness's hooks (M-ADR 0220 §4.6).
+        {
             const settingsResult = await syncMethodManagedSettings({
                 targetRepo: opts.targetRepo,
-                profile,
                 allowOverwrite: opts.allowOverwrite || migrateFrom !== null,
-                // A lock is the only sound evidence the managed entries were seeded
-                // before, which is what makes a re-seed distinguishable from a first
-                // sync into an adopter's own settings file.
-                hadPreviousSync: prevLock !== null,
                 ...(opts.agentHarness ? { agentHarness: opts.agentHarness } : {}),
             });
             if (settingsResult.refused) {
-                const conflicts = [];
-                if (settingsResult.drifted.length > 0)
-                    conflicts.push(`mcpServers: ${settingsResult.drifted.join(", ")}`);
-                if (settingsResult.hooksDrifted.length > 0)
-                    conflicts.push(`hooks: ${settingsResult.hooksDrifted.join(", ")}`);
-                stdout(fail(`.claude/settings.json has adopter-modified method entries (${conflicts.join("; ")}). Re-run with --allow-overwrite to rewrite them.`));
+                stdout(fail(`.claude/settings.json has adopter-modified method entries (hooks: ${settingsResult.hooksDrifted.join(", ")}). Re-run with --allow-overwrite to rewrite them.`));
                 return { exitCode: 1 };
             }
-            // Drift-class line of its own, ahead of the refresh summary: these
-            // entries were seeded by an earlier sync and had been removed since.
-            // Restoring them is not the news — that they went missing is, and the
-            // same ids reappearing here every sync means something is removing them
-            // repeatedly.
-            if (settingsResult.reseeded.length > 0) {
-                stdout(info(`${settingsResult.path}: RE-SEEDED ${settingsResult.reseeded.length} method-managed entr${settingsResult.reseeded.length === 1 ? "y" : "ies"} (${settingsResult.reseeded.join(", ")}) — present after a previous sync, absent now. Restored; if this recurs, something in this repo is removing them.`));
-            }
             if (settingsResult.wroteFile) {
                 const labels = [];
-                if (settingsResult.added.length > 0)
-                    labels.push(`mcp added: ${settingsResult.added.join(", ")}`);
-                if (settingsResult.updated.length > 0)
-                    labels.push(`mcp updated: ${settingsResult.updated.join(", ")}`);
+                if (settingsResult.retiredServers.length > 0)
+                    labels.push(`removed the method's retired MCP server entry: ${settingsResult.retiredServers.join(", ")} (M-ADR 0220)`);
                 if (settingsResult.hooksChangedEvents.length > 0)
                     labels.push(`hooks: ${settingsResult.hooksChangedEvents.join(", ")}`);
                 stdout(info(`Refreshed ${settingsResult.path} (${labels.join("; ") || "no changes"}).`));

package/dist/lib/sync/settings-merge.js

@@ -1,145 +1,99 @@
 /**
- * `.claude/settings.json` merge pass during `sdd-cli sync`. Method-
- * managed `mcpServers` entries (see src/lib/mcp-seed/) get upserted;
- * any adopter-added entries or other top-level keys are preserved.
+ * `.claude/settings.json` merge pass during `sdd-cli sync`. The method's hooks (see
+ * src/lib/hooks-seed/) are upserted when the repo runs the claude-code harness; every adopter
+ * entry and every other top-level key is preserved.
  *
- * The file cannot ship in the method baseline bundle because it
- * carries per-adopter absolute paths. That's why this is a separate
- * sync step, outside the bundle-driven `copyManagedFiles` path.
+ * The method seeds no MCP server (M-ADR 0220 §4.5). Sync removes the `sdd-mcp` entry it seeded
+ * before, without --allow-overwrite, because an entry whose command is the method's own
+ * `sdd-cli mcp serve` is the method's output: the same rule by which sync retired its own
+ * SDD_REPO_PATH value. An adopter's other servers, and an `sdd-mcp` entry that runs anything
+ * else, are left alone.
  *
- * Conflict handling mirrors ADR 0114: if the adopter has manually
- * modified a method-owned entry, sync refuses unless
- * `--allow-overwrite` is passed.
+ * Conflict handling mirrors ADR 0114: if the adopter has modified a method-owned hook, sync
+ * refuses unless `--allow-overwrite` is passed.
  */
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { buildMethodManagedServers, detectManagedDrift, upsertMethodManagedServers, } from "../mcp-seed/index.js";
-import { buildMethodManagedHooks, detectHooksDrift, upsertMethodManagedHooks, } from "../hooks-seed/index.js";
+import { buildMethodManagedHooks, detectHooksDrift, normaliseOwnHookRenders, upsertMethodManagedHooks, } from "../hooks-seed/index.js";
 export const SETTINGS_REL_PATH = ".claude/settings.json";
+/** The server id the method used to seed. */
+export const RETIRED_SERVER_ID = "sdd-mcp";
+/**
+ * Whether an `mcpServers` entry is one the method seeded: `sdd-cli mcp serve` and no other field,
+ * with no env or only an SDD_REPO_PATH that resolves to the repo itself (the value older syncs
+ * wrote for a platform repo). An SDD_REPO_PATH pointing anywhere else was the adopter's own
+ * configuration, as is any other change, and the entry stays.
+ */
+export function isOwnSddMcpEntry(entry, targetRepo) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+    const e = entry;
+    if (Object.keys(e).some((k) => k !== "command" && k !== "args" && k !== "env"))
+        return false;
+    if (e["command"] !== "sdd-cli")
+        return false;
+    const args = e["args"];
+    if (!Array.isArray(args) || args.length !== 2 || args[0] !== "mcp" || args[1] !== "serve")
+        return false;
+    const env = e["env"];
+    if (env === undefined)
+        return true;
+    if (!env || typeof env !== "object" || Array.isArray(env))
+        return false;
+    const keys = Object.keys(env);
+    if (keys.length !== 1 || keys[0] !== "SDD_REPO_PATH")
+        return false;
+    const path = env["SDD_REPO_PATH"];
+    return typeof path === "string" && resolve(targetRepo, path) === resolve(targetRepo);
+}
+/** The settings with the method's own `sdd-mcp` entry removed, and which ids went. */
+export function retireOwnMcpServers(settings, targetRepo) {
+    const servers = settings["mcpServers"];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers))
+        return { settings, retired: [] };
+    const current = servers;
+    if (!(RETIRED_SERVER_ID in current) || !isOwnSddMcpEntry(current[RETIRED_SERVER_ID], targetRepo)) {
+        return { settings, retired: [] };
+    }
+    const { [RETIRED_SERVER_ID]: _retired, ...rest } = current;
+    const { mcpServers: _servers, ...others } = settings;
+    return {
+        settings: Object.keys(rest).length > 0 ? { ...others, mcpServers: rest } : others,
+        retired: [RETIRED_SERVER_ID],
+    };
+}
 export async function syncMethodManagedSettings(opts) {
     const absPath = join(opts.targetRepo, SETTINGS_REL_PATH);
+    const fileExisted = await fileExists(absPath);
     const existing = await readSettings(absPath);
-    // No profile gets an SDD_REPO_PATH any more (ruled 2026-10-01). It was written for platform
-    // repos only because the resolver treated a marker-bearing repo as one candidate among its
-    // marker-bearing siblings (MULTIPLE_SDDS_FOUND in the reverse estate's layout). The resolver now
-    // lets a platform-product repo serve itself, so the env var, an absolute, machine-specific
-    // path in a COMMITTED file, is no longer needed. A value left by an older sync that points at
-    // the repo itself is this tool's own output and is removed (normaliseSddRepoPathForDrift); a
-    // value pointing anywhere else is the adopter's and is still drift. App/integration repos
-    // configure their sibling platform SDD as before.
-    const owned = buildMethodManagedServers({});
-    // Drift is detected against a PATH-NORMALISED view of the existing file,
-    // not the raw bytes. Reason, measured on a live estate: the F27 defect
-    // wrote the literal CLI argument (".") as SDD_REPO_PATH. Once the
-    // generator was fixed to emit the absolute form, a strict comparison
-    // classified the defect's own historical output as an ADOPTER
-    // modification and refused to correct it — while the only offered remedy,
-    // --allow-overwrite, is the flag that rewrites genuinely adopter-owned
-    // keys. A repair that requires the dangerous flag is not a repair. So: an
-    // existing SDD_REPO_PATH that RESOLVES (from the target repo) to the same
-    // absolute path as the generated value is the tool's own output in an
-    // older costume, and is treated as regenerable, never as drift. The raw
-    // `existing` still flows into the upsert below, so the merge rewrites the
-    // stale form to the canonical one — the sync self-heals instead of
-    // wedging. A path that resolves DIFFERENTLY is still drift.
-    const drifted = detectManagedDrift(normaliseSddRepoPathForDrift(existing, owned, opts.targetRepo), owned);
-    // Computed from the state as READ, before any upsert: which method-managed ids
-    // were absent from the file this run opened. Combined with `hadPreviousSync`
-    // that is a re-seed; without it, a first seeding. Deliberately not derived
-    // from the upsert's `added`, which cannot tell the two apart — that conflation
-    // IS the defect.
-    const absentOnRead = absentManagedIds(existing, owned);
-    const reseeded = opts.hadPreviousSync === true ? absentOnRead : [];
     const hooksActive = opts.agentHarness === "claude-code";
     const ownedHooks = hooksActive ? buildMethodManagedHooks() : undefined;
     const hooksDrifted = hooksActive && ownedHooks
-        ? detectHooksDrift(existing, ownedHooks)
+        ? detectHooksDrift(normaliseOwnHookRenders(existing, ownedHooks), ownedHooks)
         : [];
-    if ((drifted.length > 0 || hooksDrifted.length > 0) && !opts.allowOverwrite) {
-        return {
-            path: SETTINGS_REL_PATH,
-            drifted,
-            added: [],
-            // Reported even on the refusal path: the re-seed was OBSERVED when the
-            // file was read, and it stays true whether or not this run went on to
-            // write. Zeroing it here would make a refusal hide a second finding.
-            reseeded,
-            updated: [],
-            unchanged: [],
-            hooksChangedEvents: [],
-            hooksDrifted,
-            wroteFile: false,
-            refused: true,
-        };
+    const base = { path: SETTINGS_REL_PATH, hooksDrifted };
+    if (hooksDrifted.length > 0 && !opts.allowOverwrite) {
+        return { ...base, retiredServers: [], hooksChangedEvents: [], wroteFile: false, refused: true };
     }
+    const retirement = retireOwnMcpServers(existing, opts.targetRepo);
     if (opts.checkOnly) {
-        return {
-            path: SETTINGS_REL_PATH,
-            drifted,
-            added: [],
-            reseeded,
-            updated: [],
-            unchanged: [],
-            hooksChangedEvents: [],
-            hooksDrifted,
-            wroteFile: false,
-            refused: false,
-        };
+        return { ...base, retiredServers: retirement.retired, hooksChangedEvents: [], wroteFile: false, refused: false };
     }
-    const mcpResult = upsertMethodManagedServers(existing, owned);
-    let nextSettings = mcpResult.settings;
+    let nextSettings = retirement.settings;
     let hooksChangedEvents = [];
     if (hooksActive && ownedHooks) {
         const hooksResult = upsertMethodManagedHooks(nextSettings, ownedHooks);
         nextSettings = hooksResult.settings;
         hooksChangedEvents = [...hooksResult.changedEvents];
     }
-    const changed = mcpResult.changed || hooksChangedEvents.length > 0;
-    if (!changed) {
-        return {
-            path: SETTINGS_REL_PATH,
-            drifted,
-            added: mcpResult.added,
-            reseeded,
-            updated: mcpResult.updated,
-            unchanged: mcpResult.unchanged,
-            hooksChangedEvents: [],
-            hooksDrifted,
-            wroteFile: false,
-            refused: false,
-        };
+    const changed = retirement.retired.length > 0 || hooksChangedEvents.length > 0;
+    // Nothing to write: leave the file as it is, and never create one just to hold nothing.
+    if (!changed || (!fileExisted && Object.keys(nextSettings).length === 0)) {
+        return { ...base, retiredServers: [], hooksChangedEvents: [], wroteFile: false, refused: false };
     }
     await mkdir(dirname(absPath), { recursive: true });
     await writeFile(absPath, JSON.stringify(nextSettings, null, 2) + "\n", "utf8");
-    return {
-        path: SETTINGS_REL_PATH,
-        drifted,
-        added: mcpResult.added,
-        reseeded,
-        updated: mcpResult.updated,
-        unchanged: mcpResult.unchanged,
-        hooksChangedEvents,
-        hooksDrifted,
-        wroteFile: true,
-        refused: false,
-    };
-}
-/**
- * Method-managed ids absent from the settings file as read.
- *
- * A missing or malformed `mcpServers` map counts every managed id as absent —
- * `readSettings` already collapses an unparseable file to `{}`, and a file whose
- * managed block was destroyed rather than edited is exactly the re-seed case
- * this exists to name.
- */
-function absentManagedIds(existing, owned) {
-    const servers = existing["mcpServers"];
-    const present = servers && typeof servers === "object" && !Array.isArray(servers)
-        ? servers
-        : {};
-    return Object.keys(owned)
-        .filter((id) => !(id in present))
-        .sort();
+    return { ...base, retiredServers: retirement.retired, hooksChangedEvents, wroteFile: true, refused: false };
 }
 async function readSettings(absPath) {
     if (!(await fileExists(absPath)))
@@ -167,50 +121,4 @@ async function fileExists(path) {
         return false;
     }
 }
-/**
- * A view of `existing` for drift detection ONLY: where a method-managed
- * entry's `env.SDD_REPO_PATH` resolves (from the target repo) to the same
- * absolute path as the generated value, substitute the generated form.
- *
- * This makes "the tool's own older output" (the F27 relative-path defect,
- * or a lexically different spelling of the same location) compare as
- * pristine, so the merge proceeds and REWRITES it — while a path that
- * resolves somewhere else entirely remains drift and still refuses.
- * Never used for the write: the raw `existing` flows into the upsert, so
- * the correction actually lands on disk.
- */
-function normaliseSddRepoPathForDrift(existing, owned, targetRepo) {
-    const servers = existing["mcpServers"];
-    if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
-        return existing;
-    }
-    const current = servers;
-    const out = {};
-    let touched = false;
-    for (const [id, entry] of Object.entries(current)) {
-        const existingPath = entry?.env?.["SDD_REPO_PATH"];
-        const ownedPath = owned[id]?.env?.["SDD_REPO_PATH"];
-        if (typeof existingPath === "string" &&
-            ownedPath === undefined &&
-            resolve(targetRepo, existingPath) === resolve(targetRepo)) {
-            // The retired platform SDD_REPO_PATH, pointing at the repo itself: regenerable, so the
-            // drift view drops it and the write (which replaces the entry whole) removes it.
-            const { SDD_REPO_PATH: _dropped, ...rest } = entry.env ?? {};
-            const { env: _env, ...bare } = entry;
-            out[id] = Object.keys(rest).length > 0 ? { ...bare, env: rest } : bare;
-            touched = true;
-        }
-        else if (typeof existingPath === "string" &&
-            typeof ownedPath === "string" &&
-            existingPath !== ownedPath &&
-            resolve(targetRepo, existingPath) === resolve(ownedPath)) {
-            out[id] = { ...entry, env: { ...entry.env, SDD_REPO_PATH: ownedPath } };
-            touched = true;
-        }
-        else {
-            out[id] = entry;
-        }
-    }
-    return touched ? { ...existing, mcpServers: out } : existing;
-}
 //# sourceMappingURL=settings-merge.js.map

package/dist/maintain-program.js

@@ -10,7 +10,7 @@
 // (`context pull`). Plus the whole verify surface, because the personas nest.
 //
 // ⚠ As with sdd-verify, the boundary is ABSENCE, not a menu: the package ships only the import
-// closure of maintain-bin.js, so authoring verbs (init, scaffold, plan, mcp, conformance,
+// closure of maintain-bin.js, so authoring verbs (init, scaffold, plan, conformance,
 // contracts, api-surface, snapshot, metamodel, migration-map) are not present to be reached.
 // That is why every registration below imports a per-subcommand registrar, never a barrel.
 // Unclassified verbs default to AUTHOR (M-ADR 0218 §4.2) and stay out until classified.
@@ -18,6 +18,7 @@ import { Command, CommanderError } from "commander";
 import { getPackageVersion } from "./lib/package-version.js";
 import { registerVerifySurface, rejectOutsideSurface, VERIFY_SURFACE } from "./verify-program.js";
 import { registerCatalogueAggregate, registerCatalogueBuild, registerCatalogueDiff, registerCatalogueGraph } from "./verbs/catalogue-maintain.js";
+import { registerCatalogueCheck } from "./verbs/catalogue-check.js";
 import { registerContext } from "./verbs/context.js";
 import { registerGenerateBriefing } from "./verbs/generate-briefing.js";
 import { registerPackBuild } from "./verbs/pack-build.js";
@@ -30,6 +31,7 @@ export const MAINTAIN_ONLY_SURFACE = [
     "generate-briefing",
     "context pull",
     "catalogue build",
+    "catalogue check",
     "catalogue aggregate",
     "catalogue graph",
     "catalogue diff",
@@ -65,7 +67,7 @@ export function buildMaintainProgram() {
         .name("sdd-maintain")
         .description("Bring an SDD repository current and rebuild its derived model — sync, briefing, catalogue build and aggregate, pack build, context pull — plus every read-only verify verb. Cannot author specification content.")
         .version(getPackageVersion(), "-v, --version")
-        .addHelpText("after", `\nSpec: ${SPEC_URL}\nAuthoring verbs (init, scaffold, plan, mcp, conformance, …) are in @sdd-method/sdd-cli.`)
+        .addHelpText("after", `\nSpec: ${SPEC_URL}\nAuthoring verbs (scaffold, plan, conformance, …) are in @sdd-method/author-cli; init is in @sdd-method/sdd-cli.`)
         .exitOverride()
         .configureOutput({
         writeOut: (str) => process.stdout.write(str),
@@ -80,6 +82,7 @@ export function buildMaintainProgram() {
     const catalogue = program.commands.find((c) => c.name() === "catalogue");
     catalogue.description("Build, aggregate, validate and query per-SDD catalogues (ADR 0134) — the derived model");
     registerCatalogueBuild(catalogue);
+    registerCatalogueCheck(catalogue);
     registerCatalogueAggregate(catalogue);
     registerCatalogueGraph(catalogue);
     registerCatalogueDiff(catalogue);

package/dist/maintain-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.1.0",
-  "built_against_sdd_cli": "1.42.0"
+  "version": "0.2.0",
+  "built_against_sdd_cli": "1.43.0"
 }

package/dist/verbs/catalogue-check.js

@@ -0,0 +1,28 @@
+import { resolve } from "node:path";
+import { checkCataloguesFresh } from "../lib/catalogue/freshness.js";
+/**
+ * `catalogue check` (M-ADR 0220 §4.2, ruling 3): whether the committed catalogues are what the
+ * committed specifications build to. It builds into temporary space and writes nothing to the
+ * repository: `catalogue build --check` under its own name, so the author's surface holds no verb
+ * that writes the model. Its own registrar, so an artefact can carry it without the build,
+ * aggregate and graph registrations in catalogue-maintain.ts.
+ */
+export function registerCatalogueCheck(catalogue) {
+    catalogue
+        .command("check")
+        .description("Report whether the committed catalogues/ are what the committed specifications build to; builds in a temporary directory and writes nothing (exit 1 lists every stale file)")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--strict", "Treat build findings as failures")
+        .option("--snapshot-store <dir>", "Snapshot store root the binding's snapshot_area is relative to (default: $SDD_SNAPSHOT_STORE; M-ADR 0214)")
+        .action(async (opts) => {
+        const snapshotStore = opts.snapshotStore ?? process.env.SDD_SNAPSHOT_STORE;
+        const r = await checkCataloguesFresh(resolve(opts.sddPath ?? process.cwd()), {
+            label: "catalogue check",
+            ...(opts.strict !== undefined ? { strict: opts.strict } : {}),
+            ...(snapshotStore !== undefined ? { snapshotStore } : {}),
+        }, (s) => process.stdout.write(s));
+        if (r.exitCode !== 0)
+            process.exit(r.exitCode);
+    });
+}
+//# sourceMappingURL=catalogue-check.js.map

package/dist/verbs/context.js

@@ -8,7 +8,7 @@ export function registerContext(program) {
         .description("Briefing for a code repository an SDD specifies (M-ADR 0128 §1, M-ADR 0150 §4.4)");
     context
         .command("pull")
-        .description("Write agent-instructions.md, the harness wrapper's method-managed block and MCP_SETUP.md into this code repository, rendered from the templates its upstream SDD carries. The SDD is found by looking this repository up in the catalogues/repositories.csv of the SDDs beside it. Writes nothing else.")
+        .description("Write agent-instructions.md and the harness wrapper's method-managed block into this code repository, rendered from the templates its upstream SDD carries. The SDD is found by looking this repository up in the catalogues/repositories.csv of the SDDs beside it. Writes nothing else.")
         .option("--target-repo <dir>", "the code repository to write into", resolvePathOption, process.cwd())
         .option("--sdd <dir>", "the upstream SDD, skipping discovery", resolvePathOption)
         .option("--repo <id>", "this repository's id in the SDD's catalogue (default: its git top-level directory name)")

package/dist/verify-program.js

@@ -91,7 +91,7 @@ export function buildVerifyProgram() {
         .name("sdd-verify")
         .description("Verify an SDD repository without changing it — validate, list, and read-only catalogue and pack checks. Cannot write to the repository it is pointed at.")
         .version(getPackageVersion(), "-v, --version")
-        .addHelpText("after", `\nSpec: ${SPEC_URL}\nAuthoring and maintenance verbs (sync, catalogue build, init, scaffold, mcp, …) are in @sdd-method/sdd-cli.`)
+        .addHelpText("after", `\nSpec: ${SPEC_URL}\nAuthoring and maintenance verbs (sync, catalogue build, init, scaffold, …) are in @sdd-method/sdd-cli.`)
         .exitOverride()
         .configureOutput({
         writeOut: (str) => process.stdout.write(str),

package/dist/verify-version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.1.0",
-  "built_against_sdd_cli": "1.42.0"
+  "version": "1.2.0",
+  "built_against_sdd_cli": "1.43.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sdd-method/maintain-cli",
-  "version": "0.1.0",
-  "sddCliVersion": "1.42.0",
+  "version": "0.2.0",
+  "sddCliVersion": "1.43.0",
   "description": "Bring an SDD repository current and rebuild its derived model — sync, briefing, catalogue build and aggregate, pack build, context pull — plus every read-only verify verb. Ships only the code those verbs reach; it cannot author specification content. Authoring is in @sdd-method/sdd-cli.",
   "license": "Apache-2.0",
   "type": "module",