@flancer32/skill-adsm-ctx 0.2.1 → 0.4.0

package/src/Design/Service.mjs

@@ -23,13 +23,15 @@ export default class Service {
         "",
         "Recommended agent workflow:",
         "1. Identify the project class from existing repository signals or user input.",
-        "2. Keep ADSM's four top-level documentation levels under ctx/docs/: product, architecture, environment, and code.",
-        "3. Add only project-specific substructure that is justified by the project; nested directories are allowed.",
-        "4. Treat ordinary *.md files as agent-facing operational context documents and add *.skin.<lang>.md files only where human semantic control is needed.",
-        "5. Place visual, generated, rendered, or auxiliary artifacts under ctx/assets/ instead of ctx/docs/.",
-        "6. Detect whether specialized ADSM skills are needed for browser, backend, data, deployment, or other areas.",
-        "7. If a specialized skill is available, use it for that branch after the generic structure is in place.",
-        "8. If no specialized skill is available, record the specialization gap and avoid inventing details.",
+        "2. Keep ADSM's four ordered declarative documentation levels under ctx/docs/: product, architecture, environment, and code.",
+        "3. Add ctx/docs/verification/ only when a durable verification specification is justified; it is cross-cutting, not a fifth level.",
+        "4. Place each verification specification under the category of its primary declaration target and link secondary targets instead of duplicating it.",
+        "5. Add only project-specific substructure that is justified by the project; nested directories are allowed.",
+        "6. Treat ordinary *.md files as agent-facing operational context documents and add *.skin.<lang>.md files only where human semantic control is needed.",
+        "7. Place visual, generated, rendered, or auxiliary artifacts under ctx/assets/ instead of ctx/docs/.",
+        "8. Detect whether specialized ADSM skills are needed for browser, backend, data, deployment, verification execution, monitoring, or other areas.",
+        "9. If a specialized skill is available, use it for that branch after the generic structure is in place.",
+        "10. If no specialized skill is available, record the specialization gap and avoid inventing details.",
       ].join("\n");
     };
   }

package/src/Shared/Constants.mjs

@@ -8,11 +8,11 @@
 export default class Constants {
   constructor() {
     this.CONTEXT_SCHEMA = "adsm-context";
-    this.CONTEXT_VERSION = "0.1.0";
-    this.SKIN_WORD_WARN = 160;
-    this.SKIN_WORD_ERROR = 240;
-    this.SKIN_LIST_WARN = 12;
-    this.SKIN_LIST_ERROR = 20;
+    this.CONTEXT_VERSION = "0.2.0";
+    this.VERIFICATION_CAPABILITY = "verification-layer";
+    this.CONTEXT_CAPABILITIES = Object.freeze([this.VERIFICATION_CAPABILITY]);
+    this.VERIFICATION_BLOCK = "verification";
+    this.VERIFICATION_TARGETS = Object.freeze(["product", "architecture", "environment", "code"]);
     this.DOC_LEVEL_MAX_DIRECTORIES = 9;
     this.DOC_LEVEL_MAX_FILES = 9;
     this.REQUIRED_PATHS = Object.freeze([

package/src/Shared/Metadata.mjs

@@ -20,6 +20,7 @@ export default class Metadata {
       return {
         schema: constants.CONTEXT_SCHEMA,
         version: constants.CONTEXT_VERSION,
+        capabilities: [...(constants.CONTEXT_CAPABILITIES ?? [])],
       };
     };
   }

package/src/Upgrade/Service.mjs

@@ -2,7 +2,7 @@
 
 /**
  * @namespace Fl32_Skill_Adsm_Ctx_Upgrade_Service
- * @description Provides the baseline non-destructive upgrade entry point for ADSM context lifecycle.
+ * @description Provides the baseline non-destructive upgrade entry point without automatic migrations.
  */
 
 export default class Service {
@@ -13,7 +13,7 @@ export default class Service {
    */
   constructor({fs, pathService}) {
     /**
-     * Runs the upgrade entry point.
+     * Checks for context metadata and reports the current migration availability.
      *
      * @param {object} params
      * @param {string} params.targetPath
@@ -31,7 +31,7 @@ export default class Service {
       }
 
       return {
-        message: "No migrations are currently available for this context.",
+        message: "No automatic migrations are available. Verification Layer adoption is optional and must not create empty scaffolding.",
         ok: true,
       };
     };

package/src/Validate/Service.mjs

@@ -5,14 +5,6 @@
  * @description Validates baseline ADSM context structure, metadata, and documentation projection shape.
  */
 
-const REQUIRED_SKIN_SECTIONS = Object.freeze([
-  "Purpose",
-  "Mental Model",
-  "Scope",
-  "Invariants",
-  "Agent Document",
-]);
-
 const LINK_PATTERN = /\[[^\]]+\]\(([^)]+)\)/g;
 const EXPLICIT_SKIN_FILENAME = /^(.*)\.skin\.([a-z]{2}(?:-[A-Za-z0-9]+)?)\.md$/;
 const LEGACY_SKIN_FILENAME = /^(.*)\.skin\.md$/;
@@ -39,7 +31,7 @@ export default class Validate {
      *     ruleId: string,
      *     severity: "error" | "warning"
      *   }[],
-     *   metadata: {schema: string, version: string, initializedAt?: string} | null,
+     *   metadata: {capabilities?: string[], schema: string, version: string, initializedAt?: string} | null,
      *   missingPaths: string[],
      *   ok: boolean,
      *   projectRoot: string,
@@ -48,7 +40,8 @@ export default class Validate {
      *     bodies: string[],
      *     orphanSkins: string[],
      *     pairs: {body: string, skin: string}[],
-     *     skins: string[]
+     *     skins: string[],
+     *     verification: {categories: string[], present: boolean}
      *   },
      *   warningCount: number
      * }>}
@@ -62,10 +55,16 @@ export default class Validate {
         ruleId: "required-path",
         severity: "error",
       }));
-      const metadata = readMetadata({constants, fs, pathService, projectRoot});
-      const projection = inspectProjection({constants, fs, pathService, projectRoot});
+      const metadataResult = readMetadata({constants, fs, pathService, projectRoot});
+      const projection = inspectProjection({
+        constants,
+        fs,
+        metadata: metadataResult.metadata,
+        pathService,
+        projectRoot,
+      });
 
-      if (!metadata.ok) findings.push(metadata.finding);
+      findings.push(...metadataResult.findings);
       findings.push(...projection.findings);
 
       const errorCount = findings.filter((entry) => entry.severity === "error").length;
@@ -74,7 +73,7 @@ export default class Validate {
       return {
         errorCount,
         findings,
-        metadata: metadata.ok ? metadata.metadata : null,
+        metadata: metadataResult.ok ? metadataResult.metadata : null,
         missingPaths,
         ok: errorCount === 0,
         projectRoot,
@@ -188,54 +187,80 @@ function parseSkinFilename(file) {
  * }}
  */
 function readMetadata({constants, fs, pathService, projectRoot}) {
+  const findings = [];
   const metadataPath = pathService.join(projectRoot, "ctx", "adsm.json");
   if (!fs.existsSync(metadataPath)) {
-    return {
-      ok: false,
-      finding: createFinding({
-        message: "Missing ctx/adsm.json",
-        path: "ctx/adsm.json",
-        ruleId: "metadata-file",
-        severity: "error",
-      }),
-    };
+    findings.push(createFinding({
+      message: "Missing ctx/adsm.json",
+      path: "ctx/adsm.json",
+      ruleId: "metadata-file",
+      severity: "error",
+    }));
+    return {findings, metadata: null, ok: false};
   }
 
   try {
     const parsed = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
     if (parsed.schema !== constants.CONTEXT_SCHEMA) {
-      return {
-        ok: false,
-        finding: createFinding({
-          message: `Unexpected schema: ${parsed.schema}`,
-          path: "ctx/adsm.json",
-          ruleId: "metadata-schema",
-          severity: "error",
-        }),
-      };
+      findings.push(createFinding({
+        message: `Unexpected schema: ${parsed.schema}`,
+        path: "ctx/adsm.json",
+        ruleId: "metadata-schema",
+        severity: "error",
+      }));
     }
     if (!parsed.version) {
-      return {
-        ok: false,
-        finding: createFinding({
-          message: "Missing metadata version",
+      findings.push(createFinding({
+        message: "Missing metadata version",
+        path: "ctx/adsm.json",
+        ruleId: "metadata-version",
+        severity: "error",
+      }));
+    }
+
+    if (Object.hasOwn(parsed, "capabilities")) {
+      if (!Array.isArray(parsed.capabilities)) {
+        findings.push(createFinding({
+          message: "Metadata capabilities must be an array of unique strings",
           path: "ctx/adsm.json",
-          ruleId: "metadata-version",
+          ruleId: "metadata-capabilities",
           severity: "error",
-        }),
-      };
+        }));
+      } else {
+        const seen = new Set();
+        for (const capability of parsed.capabilities) {
+          if (typeof capability !== "string" || capability.length === 0 || seen.has(capability)) {
+            findings.push(createFinding({
+              message: "Metadata capabilities must be an array of unique non-empty strings",
+              path: "ctx/adsm.json",
+              ruleId: "metadata-capabilities",
+              severity: "error",
+            }));
+            break;
+          }
+          seen.add(capability);
+          if (!(constants.CONTEXT_CAPABILITIES ?? []).includes(capability)) {
+            findings.push(createFinding({
+              message: `Unknown context capability: ${capability}`,
+              path: "ctx/adsm.json",
+              ruleId: "metadata-capability-unknown",
+              severity: "warning",
+            }));
+          }
+        }
+      }
     }
-    return {ok: true, metadata: parsed};
+
+    const ok = findings.every((entry) => entry.severity !== "error");
+    return {findings, metadata: ok ? parsed : null, ok};
   } catch (error) {
-    return {
-      ok: false,
-      finding: createFinding({
-        message: `Invalid metadata JSON: ${error instanceof Error ? error.message : "Unknown error"}`,
-        path: "ctx/adsm.json",
-        ruleId: "metadata-json",
-        severity: "error",
-      }),
-    };
+    findings.push(createFinding({
+      message: `Invalid metadata JSON: ${error instanceof Error ? error.message : "Unknown error"}`,
+      path: "ctx/adsm.json",
+      ruleId: "metadata-json",
+      severity: "error",
+    }));
+    return {findings, metadata: null, ok: false};
   }
 }
 
@@ -261,7 +286,7 @@ function readMetadata({constants, fs, pathService, projectRoot}) {
  *   }
  * }}
  */
-function inspectProjection({constants, fs, pathService, projectRoot}) {
+function inspectProjection({constants, fs, metadata, pathService, projectRoot}) {
   const docsRoot = pathService.join(projectRoot, "ctx", "docs");
   const assetsRoot = pathService.join(projectRoot, "ctx", "assets");
   const findings = [];
@@ -311,6 +336,26 @@ function inspectProjection({constants, fs, pathService, projectRoot}) {
     pathService,
     projectRoot,
   }));
+  const verification = inspectVerificationBlock({
+    constants,
+    docsEntryMap,
+    fs,
+    pathService,
+    projectRoot,
+  });
+  findings.push(...verification.findings);
+  if (
+    verification.summary.present
+    && metadata
+    && !metadata.capabilities?.includes(constants.VERIFICATION_CAPABILITY)
+  ) {
+    findings.push(createFinding({
+      message: `Verification block is present without declared ${constants.VERIFICATION_CAPABILITY} capability`,
+      path: "ctx/adsm.json",
+      ruleId: "verification-capability-undocumented",
+      severity: "warning",
+    }));
+  }
 
   const markdownFiles = [];
   for (const file of listFiles({fs, pathService, root: docsRoot, prefix: "ctx/docs"})) {
@@ -373,10 +418,129 @@ function inspectProjection({constants, fs, pathService, projectRoot}) {
       orphanSkins,
       pairs,
       skins,
+      verification: verification.summary,
     },
   };
 }
 
+/**
+ * Inspects optional Verification Layer adoption without treating it as a fifth
+ * declarative documentation level.
+ *
+ * @param {object} params
+ * @param {Fl32_Skill_Adsm_Ctx_Shared_Constants} params.constants
+ * @param {Map<string, {name: string, isDirectory: () => boolean, isFile: () => boolean}>} params.docsEntryMap
+ * @param {typeof import("node:fs")} params.fs
+ * @param {Fl32_Skill_Adsm_Ctx_Shared_Path} params.pathService
+ * @param {string} params.projectRoot
+ * @returns {{
+ *   findings: {message: string, path: string, ruleId: string, severity: "error" | "warning"}[],
+ *   summary: {categories: string[], present: boolean}
+ * }}
+ */
+function inspectVerificationBlock({constants, docsEntryMap, fs, pathService, projectRoot}) {
+  const findings = [];
+  const summary = {categories: [], present: false};
+  const entry = docsEntryMap.get(constants.VERIFICATION_BLOCK);
+  if (!entry) return {findings, summary};
+
+  summary.present = true;
+  const verificationPath = `ctx/docs/${constants.VERIFICATION_BLOCK}`;
+  if (!entry.isDirectory()) {
+    findings.push(createFinding({
+      message: `Verification block is not a directory: ${verificationPath}`,
+      path: verificationPath,
+      ruleId: "verification-block",
+      severity: "error",
+    }));
+    return {findings, summary};
+  }
+
+  let entries = [];
+  try {
+    entries = listEntries({
+      fs,
+      root: pathService.join(projectRoot, ...verificationPath.split("/")),
+    });
+  } catch (error) {
+    findings.push(createFinding({
+      message: `Unreadable verification block (${error instanceof Error ? error.message : "Unknown error"})`,
+      path: verificationPath,
+      ruleId: "verification-block-readable",
+      severity: "error",
+    }));
+    return {findings, summary};
+  }
+
+  const agentsEntry = entries.find((candidate) => candidate.name === "AGENTS.md");
+  if (!agentsEntry?.isFile()) {
+    findings.push(createFinding({
+      message: `Verification block requires ${verificationPath}/AGENTS.md`,
+      path: `${verificationPath}/AGENTS.md`,
+      ruleId: "verification-agents",
+      severity: "error",
+    }));
+  }
+
+  const targets = constants.VERIFICATION_TARGETS ?? constants.DOC_LEVELS;
+  for (const child of entries) {
+    if (child.name === "AGENTS.md") continue;
+    if (!targets.includes(child.name)) {
+      if (child.isDirectory()) {
+        findings.push(createFinding({
+          message: `Unsupported verification category: ${child.name}`,
+          path: `${verificationPath}/${child.name}`,
+          ruleId: "verification-category",
+          severity: "error",
+        }));
+      }
+      continue;
+    }
+
+    if (!child.isDirectory()) {
+      findings.push(createFinding({
+        message: `Verification category is not a directory: ${child.name}`,
+        path: `${verificationPath}/${child.name}`,
+        ruleId: "verification-category",
+        severity: "error",
+      }));
+      continue;
+    }
+
+    summary.categories.push(child.name);
+    const categoryPath = `${verificationPath}/${child.name}`;
+    const documents = listFiles({
+      fs,
+      pathService,
+      prefix: categoryPath,
+      root: pathService.join(projectRoot, ...categoryPath.split("/")),
+    }).filter((file) => (
+      file.endsWith(".md")
+      && !file.endsWith("/AGENTS.md")
+      && !parseSkinFilename(file)
+    ));
+    if (documents.length === 0) {
+      findings.push(createFinding({
+        message: `Verification category has no durable specification: ${categoryPath}`,
+        path: categoryPath,
+        ruleId: "verification-empty-category",
+        severity: "error",
+      }));
+    }
+  }
+
+  if (summary.categories.length === 0) {
+    findings.push(createFinding({
+      message: `Verification block has no populated primary-target category: ${verificationPath}`,
+      path: verificationPath,
+      ruleId: "verification-empty-block",
+      severity: "error",
+    }));
+  }
+
+  return {findings, summary};
+}
+
 /**
  * Warns when a documentation level exceeds the recommended direct-entry capacity
  * and requires its local AGENTS.md to make an intentional exception explicit.
@@ -586,129 +750,17 @@ function validateSkinDocument({bodySet, constants, file, skinInfo, text}) {
       severity: "error",
     }));
   }
-  const headings = extractLevelTwoHeadings(text);
-  for (const section of REQUIRED_SKIN_SECTIONS) {
-    if (!headings.includes(section)) {
-      findings.push(createFinding({
-        message: `Missing skin section "${section}": ${file}`,
-        path: file,
-        ruleId: "skin-required-sections",
-        severity: "error",
-      }));
-    }
-  }
-
-  const scopeText = extractSectionBody({sectionName: "Scope", text});
-  if (scopeText) {
-    if (!/^Includes:\s*$/m.test(scopeText)) {
-      findings.push(createFinding({
-        message: `Missing Includes: block in Scope: ${file}`,
-        path: file,
-        ruleId: "skin-scope-includes-excludes",
-        severity: "error",
-      }));
-    }
-    if (!/^Excludes:\s*$/m.test(scopeText)) {
-      findings.push(createFinding({
-        message: `Missing Excludes: block in Scope: ${file}`,
-        path: file,
-        ruleId: "skin-scope-includes-excludes",
-        severity: "error",
-      }));
-    }
-  }
-
-  const declaredReference = extractAgentDocumentReference(text);
-  if (!declaredReference) {
-    findings.push(createFinding({
-      message: `Missing Agent Document reference: ${file}`,
-      path: file,
-      ruleId: "skin-agent-document-reference",
-      severity: "error",
-    }));
-    findings.push(...validateSkinMetrics({constants, file, text}));
-    return findings;
-  }
-
-  const expectedReference = skinInfo.body;
-  const normalizedReference = normalizeAgentDocumentReference({reference: declaredReference, skinFile: file});
-  if (normalizedReference !== expectedReference) {
+  if (/^#{1,6}\s+Agent Document\s*#*\s*$/mi.test(text)) {
     findings.push(createFinding({
-      message: `Skin agent document mismatch: ${file} references ${normalizedReference} but expected ${expectedReference}`,
+      message: "Redundant Agent Document section: skin pairing is derived from its filename",
       path: file,
-      ruleId: "skin-agent-document-reference",
+      ruleId: "skin-redundant-agent-document-section",
       severity: "error",
     }));
   }
-  if (!bodySet.has(normalizedReference)) {
-    findings.push(createFinding({
-      message: `Missing paired agent document: ${file} references ${normalizedReference}`,
-      path: file,
-      ruleId: "skin-paired-agent-document",
-      severity: "error",
-    }));
-  }
-
-  findings.push(...validateSkinMetrics({constants, file, text}));
   return findings;
 }
 
-/**
- * @param {object} params
- * @param {Fl32_Skill_Adsm_Ctx_Shared_Constants} params.constants
- * @param {string} params.file
- * @param {string} params.text
- * @returns {{message: string, path: string, ruleId: string, severity: "error" | "warning"}[]}
- */
-function validateSkinMetrics({constants, file, text}) {
-  const findings = [];
-  const metricText = extractSkinMetricText(text);
-  const wordCount = countWords(metricText);
-  const listCount = countMeaningfulListItems(metricText);
-
-  if (wordCount > constants.SKIN_WORD_ERROR) {
-    findings.push(createFinding({
-      message: `Skin word count ${wordCount} exceeds limit ${constants.SKIN_WORD_ERROR}`,
-      path: file,
-      ruleId: "skin-size-word-count",
-      severity: "error",
-    }));
-  } else if (wordCount > constants.SKIN_WORD_WARN) {
-    findings.push(createFinding({
-      message: `Skin word count ${wordCount} exceeds warning threshold ${constants.SKIN_WORD_WARN}`,
-      path: file,
-      ruleId: "skin-size-word-count",
-      severity: "warning",
-    }));
-  }
-
-  if (listCount > constants.SKIN_LIST_ERROR) {
-    findings.push(createFinding({
-      message: `Skin list count ${listCount} exceeds limit ${constants.SKIN_LIST_ERROR}`,
-      path: file,
-      ruleId: "skin-size-list-count",
-      severity: "error",
-    }));
-  } else if (listCount > constants.SKIN_LIST_WARN) {
-    findings.push(createFinding({
-      message: `Skin list count ${listCount} exceeds warning threshold ${constants.SKIN_LIST_WARN}`,
-      path: file,
-      ruleId: "skin-size-list-count",
-      severity: "warning",
-    }));
-  }
-
-  return findings;
-}
-
-/**
- * @param {string} text
- * @returns {string[]}
- */
-function extractLevelTwoHeadings(text) {
-  return [...text.matchAll(/^##\s+(.+)$/gm)].map((match) => match[1].trim());
-}
-
 /**
  * @param {object} params
  * @param {string} params.sectionName
@@ -731,46 +783,6 @@ function extractSectionBody({sectionName, text}) {
   return body.join("\n");
 }
 
-/**
- * @param {string} text
- * @returns {string | null}
- */
-function extractAgentDocumentReference(text) {
-  const lines = text.split("\n");
-  let insideSection = false;
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!insideSection) {
-      if (line === "## Agent Document") insideSection = true;
-      continue;
-    }
-    if (line.startsWith("## ")) break;
-    if (line.length > 0) return line;
-  }
-  return null;
-}
-
-/**
- * @param {object} params
- * @param {string} params.reference
- * @param {string} params.skinFile
- * @returns {string}
- */
-function normalizeAgentDocumentReference({reference, skinFile}) {
-  let value = reference.trim();
-  const codeMatch = value.match(/^`(.+)`$/);
-  if (codeMatch) value = codeMatch[1].trim();
-  const linkMatch = value.match(/^\[[^\]]+\]\(([^)]+)\)$/);
-  if (linkMatch) value = linkMatch[1].trim();
-  if (value.startsWith("./")) value = value.slice(2);
-  if (value.startsWith("ctx/docs/")) return value;
-
-  const skinParts = skinFile.split("/");
-  skinParts.pop();
-  skinParts.push(value);
-  return normalizeRelativeSegments(skinParts).join("/");
-}
-
 /**
  * @param {object} params
  * @param {string} params.file
@@ -818,60 +830,6 @@ function normalizeRelativeSegments(parts) {
   return result;
 }
 
-/**
- * @param {string} text
- * @returns {string}
- */
-function stripFencedCodeBlocks(text) {
-  return text.replace(/```[\s\S]*?```/g, "");
-}
-
-/**
- * Extracts semantic skin content while excluding metadata, headings, and the
- * Agent Document reference.
- *
- * @param {string} text
- * @returns {string}
- */
-function extractSkinMetricText(text) {
-  return ["Purpose", "Mental Model", "Scope", "Invariants"]
-    .map((sectionName) => extractSectionBody({sectionName, text}))
-    .join("\n")
-    .replace(/^\s{0,3}#{1,6}\s+.*$/gm, "")
-    .replace(/^\s*(?:Includes|Excludes):\s*$/gm, "");
-}
-
-/**
- * @param {string} text
- * @returns {string}
- */
-function stripSkinPresentation(text) {
-  return stripFencedCodeBlocks(text)
-    .split("\n")
-    .filter((line) => !/^#/.test(line.trim()))
-    .filter((line) => !/^- (?:Path|Changed): `[^`]+`$/.test(line.trim()))
-    .join("\n");
-}
-
-/**
- * @param {string} text
- * @returns {number}
- */
-function countWords(text) {
-  const matches = stripFencedCodeBlocks(text).match(/(?:\p{L}[\p{L}\p{M}\p{N}'’_-]*|\p{N}+)/gu);
-  return matches ? matches.length : 0;
-}
-
-/**
- * @param {string} text
- * @returns {number}
- */
-function countMeaningfulListItems(text) {
-  return [...stripFencedCodeBlocks(text).matchAll(/^\s*(?:[-*+]|\d+[.)])\s+(.+)$/gmu)]
-    .filter((match) => countWords(match[1]) > 0)
-    .length;
-}
-
 export const __deps__ = Object.freeze({
   constants: "Fl32_Skill_Adsm_Ctx_Shared_Constants$",
   fs: "node:fs",

package/types.d.ts

@@ -1,6 +1,9 @@
 declare global {
-  type Fl32_Skill_Adsm_Ctx_Bootstrap = import("./src/Bootstrap.mjs").default;
-  type Fl32_Skill_Adsm_Ctx_Bootstrap_Cli = import("./src/Bootstrap/Cli.mjs").default;
+  type Fl32_Skill_Adsm_Ctx_Cli_Command_Design = import("./src/Cli/Command/Design.mjs").default;
+  type Fl32_Skill_Adsm_Ctx_Cli_Command_Init = import("./src/Cli/Command/Init.mjs").default;
+  type Fl32_Skill_Adsm_Ctx_Cli_Command_InstallSkill = import("./src/Cli/Command/InstallSkill.mjs").default;
+  type Fl32_Skill_Adsm_Ctx_Cli_Command_Upgrade = import("./src/Cli/Command/Upgrade.mjs").default;
+  type Fl32_Skill_Adsm_Ctx_Cli_Command_Validate = import("./src/Cli/Command/Validate.mjs").default;
   type Fl32_Skill_Adsm_Ctx_Design_Service = import("./src/Design/Service.mjs").default;
   type Fl32_Skill_Adsm_Ctx_Init_Service = import("./src/Init/Service.mjs").default;
   type Fl32_Skill_Adsm_Ctx_Shared_Constants = import("./src/Shared/Constants.mjs").default;