@sdd-method/verify-cli 0.4.0 → 1.1.0-rc.0

package/dist/lib/catalogue/canonical-schema.yaml

@@ -7,7 +7,7 @@
 # Emitted by sdd-cli's YAML emitter with no line folding; the three header scalars are quoted for the
 # textual readers downstream. The one deliberate difference from the authored form is schema_status:
 # the authored form says canonical; a projection never does.
-schema_version: "3.19.0"
+schema_version: "3.20.0"
 schema_owner: "sdd-method"
 schema_status: "generated"
 enums:
@@ -606,6 +606,13 @@ enums:
     - value: no-canonical-home
       description: "The platform has no canonical field for the item: platform contract work."
     description: Why an unsupported feature is unsupported, and so whose work the gap is.
+  repo_dependency_kind:
+    values:
+    - value: library
+      description: Linked or packaged at build time.
+    - value: generated-from
+      description: Its content was produced from the other repository's templates.
+    description: How one repository depends on another's code (M-ADR 0217 §4.1).
 catalogues:
   domains:
     primary_key: id
@@ -688,6 +695,10 @@ catalogues:
       type: string
       nullable: true
       description: "`true` when this SDD is a reference exemplar — it demonstrates a profile shape rather than modelling a real product or provider relationship. Empty otherwise, which is the unmarked norm (absent in the manifest = a real SDD, no finding). From the manifest's `exemplar:` field (sdd-manifest-schema 1.8.0). PROFILE-AGNOSTIC, unlike surface/packaging/application_archetype which are application-product-only — the first exemplar cohort found was integration-products. DERIVED, not authorable: this column and `integrations.exemplar` both come from the one manifest field, so they cannot disagree; two independently authored copies could, which is the failure mode the trait exists to remove. No builder branches on it — it is emitted to be filterable and nothing consumes it, because an implicit exclusion inside a rollup is much harder to remove than to add. Added in 2.46.0."
+    - name: shared_library
+      type: string
+      nullable: true
+      description: "`true` when this SDD exists to provide code other SDDs build from or generate from (M-ADR 0217 §4.4). Empty otherwise, the unmarked norm. From the SDD manifest's `shared_library:` field. PROFILE-AGNOSTIC, like `exemplar`. DERIVED, not authorable: this column and its twin on the other catalogue come from the one manifest field, so they cannot disagree. No builder branches on it; a rollup filters on it. Added in 3.20.0."
     - name: surface
       type: string
       nullable: true
@@ -778,6 +789,10 @@ catalogues:
       type: string
       nullable: true
       description: "`true` when this SDD is a reference exemplar — it demonstrates a profile shape rather than modelling a real product or provider relationship. Empty otherwise, which is the unmarked norm (absent in the manifest = a real SDD, no finding). From the manifest's `exemplar:` field (sdd-manifest-schema 1.8.0). PROFILE-AGNOSTIC, unlike surface/packaging/application_archetype which are application-product-only — the first exemplar cohort found was integration-products. DERIVED, not authorable: this column and `integrations.exemplar` both come from the one manifest field, so they cannot disagree; two independently authored copies could, which is the failure mode the trait exists to remove. No builder branches on it — it is emitted to be filterable and nothing consumes it, because an implicit exclusion inside a rollup is much harder to remove than to add. Added in 2.46.0."
+    - name: shared_library
+      type: string
+      nullable: true
+      description: "`true` when this SDD exists to provide code other SDDs build from or generate from (M-ADR 0217 §4.4). Empty otherwise, the unmarked norm. From the SDD manifest's `shared_library:` field. PROFILE-AGNOSTIC, like `exemplar`. DERIVED, not authorable: this column and its twin on the other catalogue come from the one manifest field, so they cannot disagree. No builder branches on it; a rollup filters on it. Added in 3.20.0."
     - name: surface
       type: string
       nullable: true
@@ -871,6 +886,10 @@ catalogues:
       type: string
       nullable: true
       description: "`true` when the emitting SDD is a reference exemplar (demonstrates a profile shape rather than modelling a real provider relationship); empty otherwise. Derived from the SDD manifest's `exemplar:` field (sdd-manifest-schema 1.8.0), same source as `products.exemplar` — neither column is independently authorable. Carried on `sub_integrations` rows too, INHERITED from the emitting SDD. That deliberately differs from `ingestion_pattern`/`invocation_pattern`, which are empty on sub rows, and the difference is the point: a pattern is a MECHANISM (how this integration acquires data), genuinely one per SDD, whereas `exemplar` is a REALITY STATUS that propagates to everything the SDD emits — if the SDD is a demonstration then every provider relationship it declares is a demonstration. Leaving sub rows empty would flag the umbrella and count its demonstration sub-providers as real, reproducing the rollup overcount this column exists to fix one level down. Do not normalise it to match the pattern columns. The trade accepted: a real SDD with one demonstration sub-provider is unexpressible — a state that should not exist. Added in 2.46.0."
+    - name: shared_library
+      type: string
+      nullable: true
+      description: "`true` when this SDD exists to provide code other SDDs build from or generate from (M-ADR 0217 §4.4). Empty otherwise, the unmarked norm. From the SDD manifest's `shared_library:` field. PROFILE-AGNOSTIC, like `exemplar`. DERIVED, not authorable: this column and its twin on the other catalogue come from the one manifest field, so they cannot disagree. No builder branches on it; a rollup filters on it. Added in 3.20.0."
     - name: source_sdd_id
       type: string
       nullable: true
@@ -4050,3 +4069,49 @@ catalogues:
       references: repositories.id
       nullable: false
       external: true
+  repo_dependency:
+    primary_key: id
+    columns:
+    - name: id
+      type: string
+      nullable: false
+      description: <from_repo_id>__<to_repo_id>__<kind>.
+    - name: from_repo_id
+      type: string
+      nullable: false
+      description: The dependent repository; one of this SDD's own.
+    - name: to_repo_id
+      type: string
+      nullable: false
+      description: The repository depended on, in this SDD or another. External at build; it must resolve at aggregation, and is never renamed or guessed to make it resolve.
+    - name: kind
+      type: string
+      nullable: false
+      description: Bound to repo_dependency_kind.
+    - name: version
+      type: string
+      nullable: true
+      description: The version or reference depended on, where the source states one; empty otherwise. The declared source wins over the derived one.
+    - name: declared_in
+      type: string
+      nullable: false
+      description: The file the row came from, relative to the SDD root; the declared source when both name the dependency.
+    - name: source_sdd_id
+      type: string
+      nullable: true
+      description: Originating SDD slug. Populated by the aggregator per M-ADR 0134.
+    - name: platform_sdd_id
+      type: string
+      nullable: true
+      description: The platform this row belongs to — sdd_id of its platform-root. Stamped by the aggregator (M-ADR 0208 §4.4).
+    description: "Edge: a repository depends on another repository's code without either being a running service — a library linked at build time, or a template family it was generated from (M-ADR 0217). The depended-on repository may belong to another SDD, which describes it; this row only references it."
+    foreign_keys:
+    - column: from_repo_id
+      references: repositories.id
+      nullable: false
+    - column: to_repo_id
+      references: repositories.id
+      nullable: false
+      external: true
+    column_enums:
+      kind: enums.repo_dependency_kind

package/dist/lib/catalogue/cli-version.js

@@ -2,9 +2,9 @@
  * sdd-cli version constant, used in error messages from the catalogue
  * builder + aggregator + validate subcommands.
  *
- * Read from package.json via getPackageVersion() to guarantee the
+ * Read from package.json via getSddCliVersion() (the ENGINE version, also in a persona package) to guarantee the
  * constant cannot drift from the published version.
  */
-import { getPackageVersion } from "../package-version.js";
-export const CLI_VERSION = getPackageVersion();
+import { getSddCliVersion } from "../package-version.js";
+export const CLI_VERSION = getSddCliVersion();
 //# sourceMappingURL=cli-version.js.map

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

@@ -215,6 +215,9 @@ const ManifestSchema = z.object({
     // application-product. Absent reads as a real SDD, the unmarked norm, with no
     // finding. Only `true` is meaningful; `false` is redundant but accepted.
     exemplar: z.boolean().optional(),
+    // 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(),
     // 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
@@ -374,6 +377,7 @@ export async function loadSddManifest(sddPath, options) {
         ...(parsed.data.surface !== undefined ? { surface: parsed.data.surface } : {}),
         ...(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.application_archetype !== undefined
             ? { applicationArchetype: parsed.data.application_archetype }
             : {}),

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

@@ -859,3 +859,13 @@ coverage:
       repo_id:
         class: xref
         impact_flow: toward-source
+  repo_dependency:
+    kind: edge
+    scoring: predicate
+    class: dependency
+    impact_flow: toward-source
+    instrument: "FK resolution against repositories at aggregation: a dependency naming no repository fails like any other foreign key (M-ADR 0217 §4.1)"
+  repo_dependency_kind:
+    kind: enum
+    scoring: not-applicable
+    reason: closed vocabulary, not an artefact

package/dist/lib/lock-file.js

@@ -62,6 +62,9 @@ export function serialiseLockFile(lock) {
     const lines = [
         `method_repo: ${lock.methodRepo}`,
         `lock_version: ${lock.lockVersion}`,
+        ...(lock.ciBinding !== undefined ? [`ci_binding: ${lock.ciBinding}`] : []),
+        ...(lock.ciWorkflowBlockSha256 !== undefined ? [`ci_workflow_block_sha256: "${lock.ciWorkflowBlockSha256}"`] : []),
+        ...(lock.ciModuleSha256 !== undefined ? [`ci_module_sha256: "${lock.ciModuleSha256}"`] : []),
         "bundles:",
     ];
     for (const b of lock.bundles) {
@@ -109,6 +112,9 @@ function stripQuotes(value) {
 function parseVersioned(raw) {
     let methodRepo;
     let lockVersion;
+    let ciWorkflowBlockSha256;
+    let ciBinding;
+    let ciModuleSha256;
     const bundles = [];
     let inBundles = false;
     let inPaths = false;
@@ -170,6 +176,12 @@ function parseVersioned(raw) {
                     methodRepo = stripQuotes(value);
                 else if (key === "lock_version")
                     lockVersion = Number(stripQuotes(value));
+                else if (key === "ci_workflow_block_sha256")
+                    ciWorkflowBlockSha256 = stripQuotes(value);
+                else if (key === "ci_binding")
+                    ciBinding = stripQuotes(value);
+                else if (key === "ci_module_sha256")
+                    ciModuleSha256 = stripQuotes(value);
             }
             continue;
         }
@@ -289,7 +301,14 @@ function parseVersioned(raw) {
                 ? ` — the lock was written by a newer sdd-cli; upgrade rather than downgrading the lock.`
                 : `.`));
     }
-    return { methodRepo, lockVersion: LOCK_VERSION, bundles };
+    return {
+        methodRepo,
+        lockVersion: LOCK_VERSION,
+        bundles,
+        ...(ciBinding !== undefined ? { ciBinding } : {}),
+        ...(ciWorkflowBlockSha256 !== undefined ? { ciWorkflowBlockSha256 } : {}),
+        ...(ciModuleSha256 !== undefined ? { ciModuleSha256 } : {}),
+    };
 }
 function migrateV1(raw, legacyBundleName) {
     const scalars = new Map();

package/dist/lib/pack/validate.js

@@ -4,7 +4,7 @@
 // (M-ADR 0212 §4.3b). `index.ts` re-exports it, so existing imports are unchanged.
 import { validateSeed } from "./schema.js";
 import { loadSeed } from "./seed.js";
-import { getPackageVersion } from "../package-version.js";
+import { getSddCliVersion } from "../package-version.js";
 import { fail, info, pass, section } from "./log.js";
 export async function runPackValidate(opts, stdout = (s) => process.stdout.write(s)) {
     stdout(section("Pack validate"));
@@ -21,7 +21,7 @@ export async function runPackValidate(opts, stdout = (s) => process.stdout.write
     // than itself, exactly as for `.sdd/sdd-manifest.yaml`. Silence here is what let an
     // adopter follow the schema and get a clean validation with no effect.
     if (seed.unknownKeys && seed.unknownKeys.length > 0) {
-        stdout(info(`${seed.unknownKeys.length} seed key(s) not understood by sdd-cli ${getPackageVersion()} ` +
+        stdout(info(`${seed.unknownKeys.length} seed key(s) not understood by sdd-cli ${getSddCliVersion()} ` +
             `and therefore IGNORED: ${seed.unknownKeys.join(", ")}. If the seed follows a newer ` +
             `context-pack-seed-schema than this build, upgrade sdd-cli; otherwise remove or correct the key.`));
     }

package/dist/lib/package-version.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 /**
  * Read the package version from package.json at runtime so the various
@@ -13,6 +13,25 @@ import { fileURLToPath } from "node:url";
  * Cached on first call.
  */
 let cached;
+let cachedEngine;
+/**
+ * The version of the sdd-cli ENGINE this code is. In @sdd-method/sdd-cli it is the package
+ * version. In a persona package (verify-cli, maintain-cli) the package version is the
+ * persona's own (0.1.0, 1.0.0), while every check and stamp that means "which sdd-cli is
+ * this" (a bundle's minimum_sdd_cli_version, the CLI version stamped into catalogues, the
+ * MCP server identity) must see the engine it was built from. The persona build writes that
+ * as `sddCliVersion` in the package's package.json. Found by maintain-cli's acceptance run:
+ * its sync refused every bundle because 0.1.0 < 1.41.0.
+ */
+export function getSddCliVersion() {
+    if (cachedEngine !== undefined)
+        return cachedEngine;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(resolve(here, "..", "..", "package.json"), "utf8"));
+    cachedEngine = pkg.sddCliVersion ?? pkg.version;
+    return cachedEngine;
+}
+/** The package's own version: what `--version` prints. For the engine version, use getSddCliVersion. */
 export function getPackageVersion() {
     if (cached !== undefined)
         return cached;
@@ -22,4 +41,52 @@ export function getPackageVersion() {
     cached = pkg.version;
     return cached;
 }
+/**
+ * The @sdd-method/verify-cli version released WITH this sdd-cli (M-ADR 0212
+ * §6.1 Phase 1). The method-managed CI workflow installs exactly this version,
+ * so the CLI that syncs a repository decides which verifier judges it.
+ *
+ * Read from dist/verify-version.json, which the build copies from
+ * scripts/verify-version.json. Never from scripts/ in a built layout: the global
+ * `sdd-cli` on the method's machines is a link into the checkout, so reading the
+ * committed file live would render a version bumped in source but not yet
+ * published into every workflow synced that day, while dist/ still lagged.
+ * Source layout (tests) has no copy and reads scripts/ directly.
+ *
+ * Throws rather than defaults: a missing version must not render a floating install.
+ */
+const cachedPersona = {};
+/**
+ * One exact npm version: X.Y.Z, optionally with a prerelease tag (1.1.0-rc.0), which a release
+ * candidate published under the `next` dist-tag needs so hosted CI can run it before the release.
+ * Never a range, a tag name or a wildcard.
+ */
+export const EXACT_VERSION = /^\d+\.\d+\.\d+(-[0-9A-Za-z]+(\.[0-9A-Za-z]+)*)?$/;
+function personaVersion(persona) {
+    const hit = cachedPersona[persona];
+    if (hit !== undefined)
+        return hit;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const fromSource = here.endsWith(`${sep}src${sep}lib`);
+    const file = fromSource
+        ? resolve(here, "..", "..", "scripts", `${persona}-version.json`)
+        : resolve(here, "..", `${persona}-version.json`);
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof parsed.version !== "string" || !EXACT_VERSION.test(parsed.version)) {
+        throw new Error(`${file} has no semver \`version\`; refusing to render an unpinned ${persona}-cli install`);
+    }
+    cachedPersona[persona] = parsed.version;
+    return parsed.version;
+}
+export function getVerifyCliVersion() {
+    return personaVersion("verify");
+}
+/**
+ * The @sdd-method/maintain-cli version released WITH this sdd-cli. The managed CI workflow's
+ * catalogue freshness step installs exactly this version (M-ADR 0218 §5; ruled 2026-10-15, sdm-jts.6).
+ * Read the same way as the verify version, for the same reason (dist/ copy, never scripts/ live).
+ */
+export function getMaintainCliVersion() {
+    return personaVersion("maintain");
+}
 //# sourceMappingURL=package-version.js.map

package/dist/lib/validate/bundle-coherence.js

@@ -11,7 +11,7 @@
 // read 0 (the scores-coverage precedent, M-ADR 0205 §4.5).
 import { readLockFile, findForwardBase } from "../lock-file.js";
 import { loadSddManifest, } from "../catalogue/manifest-loader.js";
-import { getPackageVersion } from "../package-version.js";
+import { getSddCliVersion } from "../package-version.js";
 /**
  * Manifest profile → the forward base that profile expects. Profiles with no
  * entry (support-repo, organisation-profile) carry no expectation — silence,
@@ -37,7 +37,7 @@ export async function checkBundleCoherence(targetRepo) {
     let profile;
     try {
         const manifest = await loadSddManifest(targetRepo, {
-            cliVersion: getPackageVersion(),
+            cliVersion: getSddCliVersion(),
         });
         profile = manifest.profile;
     }

package/dist/lib/validate/plan.js

@@ -0,0 +1,54 @@
+/**
+ * The method-managed validation job, as DATA (bead sdm-dd6.2; Dagger ruling sdm-s48, 2026-10-15).
+ *
+ * One ordered plan per profile: every default validator, the platform's script-only checks, then the
+ * advisory catalogue freshness check. Every executor renders or runs THIS: the GitHub workflow
+ * generator (ci-workflow.ts) and the Dagger module (via `sdd-verify validate --list`). The job list
+ * drifted once when CI kept a hand copy of the suite (2026-10-01: three validators never reached CI),
+ * so no executor may keep its own list.
+ */
+import { validatorsForProfile } from "./dispatch.js";
+/** Titles kept from the hand-kept list, so step names stay readable. */
+const TITLES = {
+    "adr-structure": "Validate ADR metadata",
+    "spec-lifecycle": "Validate spec lifecycle",
+    "no-bare-adr": "Reject bare ADR references",
+    traceability: "Validate traceability",
+    "runway-classification": "Validate runway classification",
+    "corpus-consistency": "Validate corpus consistency",
+    config: "Validate configuration",
+    "app-docs": "Validate app documentation",
+    "integration-docs": "Validate integration documentation",
+    "yaml-parse": "Validate that tracked YAML parses",
+    "gate-readiness": "Validate gate readiness",
+    "bundle-coherence": "Report bundle coherence",
+    // CI has no platform checkout, so this step runs the app-only checks; the met gate needs the platform beside it.
+    "app-dependencies": "Validate app dependencies (app-only checks; no platform checkout in CI)",
+};
+export function methodValidationPlan(profile) {
+    const steps = validatorsForProfile(profile)
+        .filter((v) => v.optional !== true)
+        .map((v) => ({
+        id: v.name,
+        title: TITLES[v.name] ?? `Validate ${v.name}`,
+        tool: "sdd-verify",
+        args: ["validate", "--target-repo", ".", "--validator", v.name],
+        advisory: false,
+    }));
+    if (profile === "platform") {
+        steps.push({ id: "cascade-completeness", title: "Validate cascade completeness", tool: "bash", args: ["orchestration/scripts/validate-cascade-completeness.sh", "all"], advisory: false }, { id: "architecture-alignment", title: "Validate architecture alignment", tool: "bash", args: ["orchestration/scripts/validate-architecture-alignment.sh"], advisory: false });
+    }
+    steps.push({
+        id: "catalogue-freshness",
+        title: "Check catalogues reproduce from the specs (advisory)",
+        tool: "sdd-maintain",
+        args: ["catalogue", "build", "--check", "--sdd-path", "."],
+        advisory: true,
+    });
+    return steps;
+}
+/** The shell form of a step, as a CI host's `run:` line writes it. */
+export function stepCommand(step) {
+    return [step.tool, ...step.args].join(" ");
+}
+//# sourceMappingURL=plan.js.map

package/dist/maintain-version.json

@@ -0,0 +1,4 @@
+{
+  "version": "0.1.0-rc.0",
+  "built_against_sdd_cli": "1.42.0"
+}

package/dist/verbs/validate.js

@@ -1,4 +1,8 @@
 import { runValidate } from "../lib/validate/index.js";
+import { methodValidationPlan } from "../lib/validate/plan.js";
+import { profileFromRepoKind, readRepoKind } from "../lib/repo-kind.js";
+const LISTABLE = ["platform", "application", "integration"];
+const isListable = (p) => LISTABLE.includes(p);
 import { resolvePathOption } from "./path-option.js";
 export function registerValidate(program) {
     program
@@ -8,7 +12,29 @@ export function registerValidate(program) {
         .option("--platform-root <dir>", "path to the sdd-method (or platform) repo, required for app-dependencies", resolvePathOption)
         .option("--validator <name>", "run only the named validator")
         .option("--strict", "treat warnings as failures")
+        .option("--list", "print the method-managed validation job for this repo's profile as JSON (the plan every CI executor runs, the Dagger module included) and run nothing")
+        .option("--profile <profile>", "with --list: the profile to list, instead of reading .sdd-repo-kind (platform | application | integration)")
         .action(async (opts) => {
+        if (opts.list === true) {
+            let profile;
+            if (opts.profile !== undefined) {
+                if (!isListable(opts.profile)) {
+                    process.stderr.write(`--profile must be platform, application or integration (got: ${opts.profile})\n`);
+                    process.exit(2);
+                }
+                profile = opts.profile;
+            }
+            else {
+                const kind = await readRepoKind(opts.targetRepo);
+                if (kind === null) {
+                    process.stderr.write(`Not an SDD repo (no .sdd-repo-kind in ${opts.targetRepo}); pass --profile\n`);
+                    process.exit(1);
+                }
+                profile = profileFromRepoKind(kind);
+            }
+            process.stdout.write(JSON.stringify({ profile, steps: methodValidationPlan(profile) }, null, 2) + "\n");
+            return;
+        }
         const { exitCode } = await runValidate({
             targetRepo: opts.targetRepo,
             ...(opts.platformRoot ? { platformRoot: opts.platformRoot } : {}),

package/dist/verify-program.js

@@ -49,7 +49,7 @@ const OUTSIDE = "is not part of sdd-verify, which cannot write to the repository
  * this binary exists to prevent. So an excluded verb fails, loudly, whatever
  * flags accompany it.
  */
-export function rejectOutsideSurface(program, argv) {
+export function rejectOutsideSurface(program, argv, outside = OUTSIDE) {
     const words = argv.filter((a) => !a.startsWith("-"));
     if (words.length === 0)
         return;
@@ -58,10 +58,10 @@ export function rejectOutsideSurface(program, argv) {
         return;
     const cmd = program.commands.find((c) => c.name() === verb);
     if (!cmd)
-        throw new Error(`'${verb}' ${OUTSIDE}`);
+        throw new Error(`'${verb}' ${outside}`);
     const subs = cmd.commands.map((c) => c.name()).filter((n) => n !== "help");
     if (subs.length > 0 && sub !== undefined && sub !== "help" && !subs.includes(sub)) {
-        throw new Error(`'${verb} ${sub}' ${OUTSIDE}`);
+        throw new Error(`'${verb} ${sub}' ${outside}`);
     }
 }
 export async function runVerify(argv) {
@@ -97,6 +97,14 @@ export function buildVerifyProgram() {
         writeOut: (str) => process.stdout.write(str),
         writeErr: (str) => process.stderr.write(str),
     });
+    registerVerifySurface(program);
+    return program;
+}
+/**
+ * The verify verbs, registered onto any program. sdd-verify calls it; sdd-maintain calls it too,
+ * which is what makes the personas nest structurally: whatever verify ships, maintain ships.
+ */
+export function registerVerifySurface(program) {
     registerValidate(program);
     registerList(program);
     const pack = program
@@ -110,6 +118,5 @@ export function buildVerifyProgram() {
     registerCatalogueImpact(catalogue);
     registerCatalogueBaselineCheck(catalogue);
     registerCatalogueVersion(catalogue);
-    return program;
 }
 //# sourceMappingURL=verify-program.js.map

package/dist/verify-version.json

@@ -0,0 +1,4 @@
+{
+  "version": "1.1.0-rc.0",
+  "built_against_sdd_cli": "1.42.0"
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@sdd-method/verify-cli",
-  "version": "0.4.0",
-  "description": "Verify an SDD repository without changing it — validate, list, and read-only catalogue and pack checks. Ships only the code those verbs reach; it cannot write to the repository it is pointed at. Authoring and maintenance are in @sdd-method/sdd-cli.",
+  "version": "1.1.0-rc.0",
+  "sddCliVersion": "1.42.0",
+  "description": "Verify an SDD repository without changing it \u2014 validate, list, and read-only catalogue and pack checks. Ships only the code those verbs reach; it cannot write to the repository it is pointed at. Authoring and maintenance are in @sdd-method/sdd-cli.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {