@modelcontextprotocol/inspector 2.5.0 → 2.6.0

package/clients/cli/build/index.js

@@ -616,7 +616,11 @@ function isOfferable(branch, merged) {
     return false;
   }
   if (!admitsObject(branch)) return false;
-  const properties = Object.values(propertiesOf(merged));
+  const mergedProperties = propertiesOf(merged);
+  if (requiredOf(merged).some((name) => !Object.hasOwn(mergedProperties, name))) {
+    return false;
+  }
+  const properties = Object.values(mergedProperties);
   return properties.length > 0 && // Every value has to be something a renderer can read AND something a
   // caller can satisfy. A `null` or an array is not a schema at all, and the
   // web form dereferences one on the way to choosing a widget. JSON Schema's
@@ -4238,6 +4242,7 @@ import {
   OAuthTokensSchema as OAuthTokensSchema2
 } from "@modelcontextprotocol/core";
 var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
+var MIN_REVOCATION_REQUEST_BUDGET_MS = 5;
 function selectRevocableToken(tokens) {
   if (!tokens) return null;
   if (tokens.refresh_token) {
@@ -4285,7 +4290,10 @@ function base64Encode(value) {
   return Buffer.from(value, "utf8").toString("base64");
 }
 async function revokeToken(params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS;
+  const timeoutMs = Math.max(
+    0,
+    Math.round(params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS)
+  );
   try {
     const { url, init } = buildRevocationRequest(params);
     const response = await withDeadline(
@@ -4473,7 +4481,7 @@ async function runPlan(plan, params) {
   if (!endpoint) return { status: "skipped", reason: "no_endpoint" };
   const outcomes = [...plan.failures];
   const timeoutMs = params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS;
-  const deadlineAt = Date.now() + timeoutMs;
+  const deadlineAt = performance.now() + timeoutMs;
   for (const grant of plan.grants) {
     if (grant.issuer === void 0) {
       outcomes.push({
@@ -4489,8 +4497,8 @@ async function runPlan(plan, params) {
       });
       continue;
     }
-    const remainingMs = deadlineAt - Date.now();
-    if (remainingMs <= 0) {
+    const remainingMs = deadlineAt - performance.now();
+    if (remainingMs <= MIN_REVOCATION_REQUEST_BUDGET_MS) {
       outcomes.push({
         status: "failed",
         endpoint,
@@ -4542,13 +4550,13 @@ async function clearStoredAuthForRelogin(serverUrl, options) {
 }
 async function sendPlans(plans, budgetMs) {
   const fetchFn = createProxyFetch() ?? fetch;
-  const deadlineAt = Date.now() + budgetMs;
+  const deadlineAt = performance.now() + budgetMs;
   let reported;
   let lastSkip;
   for (const plan of plans) {
-    const remainingMs = deadlineAt - Date.now();
+    const remainingMs = deadlineAt - performance.now();
     const needsNetwork = plan.outcome === void 0;
-    if (needsNetwork && remainingMs <= 0) {
+    if (needsNetwork && remainingMs <= MIN_REVOCATION_REQUEST_BUDGET_MS) {
       const exhausted = {
         status: "failed",
         detail: `the ${budgetMs}ms revocation budget was exhausted before "${plan.serverUrl}" was attempted`
@@ -4978,6 +4986,653 @@ function buildClientExtensions(input) {
   return map;
 }
 
+// ../../core/mcp/skillsSchemas.ts
+import { z as z2 } from "zod/v4";
+import { ResourceSchema } from "@modelcontextprotocol/core";
+var SKILLS_EXTENSION_KEY = "io.modelcontextprotocol/skills";
+var SKILLS_LIST_METHOD = "skills/list";
+var SKILLS_GET_METHOD = "skills/get";
+var RESOURCES_DIRECTORY_READ_METHOD = "resources/directory/read";
+var DYNAMIC_RESOURCES = "dynamic";
+var SkillFrontmatterSchema = z2.looseObject({
+  name: z2.string().optional(),
+  description: z2.string().optional()
+});
+var SkillResourceSchema = z2.looseObject({
+  uri: z2.string(),
+  digest: z2.string().optional(),
+  size: z2.number().optional()
+});
+var SkillEntrySchema = z2.looseObject({
+  uri: z2.string(),
+  frontmatter: SkillFrontmatterSchema,
+  resources: z2.union([
+    z2.literal(DYNAMIC_RESOURCES),
+    z2.array(SkillResourceSchema)
+  ])
+});
+var ListSkillsResultSchema = z2.looseObject({
+  skills: z2.array(SkillEntrySchema),
+  nextCursor: z2.string().optional()
+});
+var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
+  resultType: z2.literal("complete"),
+  // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
+  // envelope violation, and accepting it here would hide exactly the kind of
+  // defect this schema exists to surface.
+  ttlMs: z2.int().min(0),
+  cacheScope: z2.enum(["public", "private"])
+});
+var GetSkillEnvelopeSchema = z2.looseObject({
+  skill: SkillEntrySchema
+});
+var ModernGetSkillEnvelopeSchema = GetSkillEnvelopeSchema.extend({
+  resultType: z2.literal("complete")
+});
+var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
+  (result) => result.skill
+);
+var DirectoryChildSchema = ResourceSchema;
+var DirectoryReadResultSchema = z2.looseObject({
+  resources: z2.array(DirectoryChildSchema),
+  nextCursor: z2.string().optional()
+});
+var ModernDirectoryReadResultSchema = DirectoryReadResultSchema.extend(
+  { resultType: z2.literal("complete") }
+);
+
+// ../../core/mcp/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var H0 = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256Bytes(bytes) {
+  const message = new Uint8Array(bytes);
+  const bitLength = message.length * 8;
+  const withLength = message.length + 9;
+  const padded = new Uint8Array(Math.ceil(withLength / 64) * 64);
+  padded.set(message);
+  padded[message.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(padded.length - 4, bitLength >>> 0);
+  const h = new Uint32Array(H0);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i += 1) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const digest = new Uint8Array(32);
+  const out = new DataView(digest.buffer);
+  for (let i = 0; i < 8; i += 1) out.setUint32(i * 4, h[i]);
+  return digest;
+}
+
+// ../../core/mcp/skillFile.ts
+import { parse as parseYaml } from "yaml";
+function splitSkillFile(text) {
+  if (!/^---[ \t]*\r?\n/.test(text)) return { body: text };
+  const rest = text.slice(text.indexOf("\n") + 1);
+  const close = rest.search(/^---[ \t]*\r?$/m);
+  if (close === -1) return { body: text };
+  const frontmatter = rest.slice(0, close).replace(/\r?\n$/, "");
+  const after = rest.slice(close);
+  const newline = after.indexOf("\n");
+  if (newline === -1) return { frontmatter, body: "" };
+  return { frontmatter, body: after.slice(newline + 1).replace(/^\r?\n/, "") };
+}
+function hasContent(yamlText) {
+  return yamlText.split("\n").some((line) => line.trim() !== "" && !line.trimStart().startsWith("#"));
+}
+var MAX_FRONTMATTER_DEPTH = 64;
+function jsonGraphError(value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (typeof value !== "object" || value === null) return void 0;
+  if (depth > MAX_FRONTMATTER_DEPTH) {
+    return `Frontmatter nests deeper than ${MAX_FRONTMATTER_DEPTH} levels, which cannot be compared field by field.`;
+  }
+  const node = value;
+  if (seen.has(node)) {
+    return "Frontmatter contains a cyclic YAML alias, which has no JSON equivalent and cannot be compared against the listing.";
+  }
+  seen.add(node);
+  const members = Array.isArray(node) ? node : Object.values(node);
+  for (const member of members) {
+    const error = jsonGraphError(member, seen, depth + 1);
+    if (error) return error;
+  }
+  seen.delete(node);
+  return void 0;
+}
+function parseSkillFrontmatter(yamlText) {
+  let parsed;
+  try {
+    parsed = parseYaml(yamlText);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  if (parsed === null || parsed === void 0) {
+    return hasContent(yamlText) ? { error: "Frontmatter is not a YAML mapping of fields." } : { fields: {} };
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {
+      error: "Frontmatter is not a YAML mapping of fields."
+    };
+  }
+  const graphError = jsonGraphError(parsed, /* @__PURE__ */ new Set(), 0);
+  if (graphError) return { error: graphError };
+  return { fields: parsed };
+}
+
+// ../../core/mcp/skills.ts
+var SKILL_MAX_RESOURCE_ENTRIES = 512;
+var SKILL_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+var SKILL_MAX_CATALOG_SKILLS = 256;
+var SKILL_MAX_CATALOG_BYTES = 64 * 1024 * 1024;
+var SKILL_FILE_SUFFIX = "/SKILL.md";
+var DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
+var SKILL_DESCRIPTION_MAX_LENGTH = 1024;
+function codePointLength(value) {
+  return [...value].length;
+}
+function getSkillsExtension(capabilities) {
+  const declared = capabilities?.extensions?.[SKILLS_EXTENSION_KEY];
+  if (typeof declared !== "object" || declared === null) return void 0;
+  const directoryRead = declared.directoryRead === true;
+  return { directoryRead };
+}
+function normalizeSkillUri(uri) {
+  let parsed;
+  try {
+    parsed = new URL(uri);
+  } catch {
+    return void 0;
+  }
+  if (!parsed.pathname.startsWith("/")) return void 0;
+  return canonicalizePercentEncoding(parsed.href);
+}
+function canonicalizePercentEncoding(value) {
+  return value.replace(/%[0-9a-fA-F]{2}/g, (escape) => {
+    const char = String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+    return /[A-Za-z0-9\-._~]/.test(char) ? char : escape.toUpperCase();
+  });
+}
+function skillNameFromUri(uri) {
+  const normalized = normalizeSkillUri(uri);
+  if (normalized === void 0 || !normalized.endsWith(SKILL_FILE_SUFFIX)) {
+    return void 0;
+  }
+  const path5 = normalized.slice(0, -SKILL_FILE_SUFFIX.length);
+  const segment = path5.slice(path5.lastIndexOf("/") + 1);
+  return segment.length > 0 ? segment : void 0;
+}
+function skillUriIdentity(uri) {
+  return normalizeSkillUri(uri) ?? uri;
+}
+function skillDisplayName(entry) {
+  const declared = entry.frontmatter.name?.trim();
+  if (declared) return declared;
+  return skillNameFromUri(entry.uri) ?? entry.uri;
+}
+function checkSkillConformance(entry) {
+  const issues = [];
+  const rawName = entry.frontmatter.name;
+  const declaredName = rawName?.trim() ? rawName : void 0;
+  const uriName = skillNameFromUri(entry.uri);
+  if (!declaredName) {
+    issues.push({
+      code: "missing-name",
+      severity: "error",
+      message: "frontmatter.name is required but missing or empty."
+    });
+  } else if (codePointLength(declaredName) > SKILL_NAME_MAX_LENGTH || !SKILL_NAME_PATTERN.test(declaredName)) {
+    issues.push({
+      code: "malformed-name",
+      severity: "error",
+      message: `frontmatter.name "${declaredName}" is not a valid Agent Skills name: 1\u2013${SKILL_NAME_MAX_LENGTH} lowercase alphanumerics and hyphens, with no leading, trailing or consecutive hyphen.`
+    });
+  }
+  const rawDescription = entry.frontmatter.description;
+  if (!rawDescription?.trim()) {
+    issues.push({
+      code: "missing-description",
+      severity: "error",
+      message: "frontmatter.description is required but missing or empty."
+    });
+  } else if (codePointLength(rawDescription) > SKILL_DESCRIPTION_MAX_LENGTH) {
+    issues.push({
+      code: "malformed-description",
+      severity: "error",
+      message: `frontmatter.description is ${codePointLength(rawDescription)} characters, above the ${SKILL_DESCRIPTION_MAX_LENGTH}-character limit.`
+    });
+  }
+  if (uriName === void 0) {
+    issues.push({
+      code: "malformed-uri",
+      severity: "error",
+      message: `Skill URI must be a hierarchical URI ending with "${SKILL_FILE_SUFFIX}" and carrying a non-empty path segment before it.`
+    });
+  } else if (declaredName && uriName !== declaredName) {
+    issues.push({
+      code: "name-path-mismatch",
+      severity: "error",
+      message: `URI path segment "${uriName}" does not match frontmatter.name "${declaredName}".`
+    });
+  }
+  if (entry.resources === DYNAMIC_RESOURCES) {
+    issues.push({
+      code: "dynamic-resources",
+      severity: "warning",
+      message: 'resources is "dynamic": the file set is generated, so no digest is advertised and integrity cannot be verified.'
+    });
+    return issues;
+  }
+  if (entry.resources.length > SKILL_MAX_RESOURCE_ENTRIES) {
+    issues.push({
+      code: "resource-limit-exceeded",
+      severity: "warning",
+      message: `Skill declares ${entry.resources.length} resource entries, above the ${SKILL_MAX_RESOURCE_ENTRIES}-entry interoperability limit; a host is only required to support up to it.`
+    });
+  }
+  const totalBytes = totalSkillBytes(entry.resources);
+  if (totalBytes > SKILL_MAX_TOTAL_BYTES) {
+    issues.push({
+      code: "size-limit-exceeded",
+      severity: "warning",
+      message: `Skill resources total ${totalBytes} bytes, above the ${SKILL_MAX_TOTAL_BYTES}-byte (16 MiB) interoperability limit; a host is only required to support up to it.`
+    });
+  }
+  const entryIdentity = skillUriIdentity(entry.uri);
+  if (!entry.resources.some(
+    (resource) => skillUriIdentity(resource.uri) === entryIdentity
+  )) {
+    issues.push({
+      code: "manifest-missing-self",
+      severity: "error",
+      message: `Manifest does not list the skill's own entry file (${entry.uri}); a manifest must be the complete file set.`
+    });
+  }
+  const seenUris = /* @__PURE__ */ new Set();
+  const normalizedEntryUri = normalizeSkillUri(entry.uri);
+  const root = normalizedEntryUri !== void 0 && normalizedEntryUri.endsWith(SKILL_FILE_SUFFIX) ? `${normalizedEntryUri.slice(0, -SKILL_FILE_SUFFIX.length)}/` : void 0;
+  for (const resource of entry.resources) {
+    const identity2 = skillUriIdentity(resource.uri);
+    if (seenUris.has(identity2)) {
+      issues.push({
+        code: "duplicate-resource",
+        severity: "error",
+        message: "Manifest lists this URI more than once; entries must be unique.",
+        resourceUri: resource.uri
+      });
+    }
+    seenUris.add(identity2);
+    if (root !== void 0) {
+      const normalized = normalizeSkillUri(resource.uri);
+      if (normalized === void 0 || !normalized.startsWith(root)) {
+        issues.push({
+          code: "resource-outside-skill-root",
+          severity: "error",
+          message: `Manifest entry does not resolve inside the skill root "${root}".`,
+          resourceUri: resource.uri
+        });
+      }
+    }
+    if (resource.digest === void 0) {
+      issues.push({
+        code: "missing-digest",
+        severity: "error",
+        message: "Manifest entry declares no digest, which is required \u2014 and without it the file cannot be verified.",
+        resourceUri: resource.uri
+      });
+    } else if (!DIGEST_PATTERN.test(resource.digest)) {
+      issues.push({
+        code: "malformed-digest",
+        severity: "error",
+        message: `Digest "${resource.digest}" is not "sha256:" followed by 64 lowercase hex characters.`,
+        resourceUri: resource.uri
+      });
+    }
+    if (resource.size === void 0) {
+      issues.push({
+        code: "missing-size",
+        severity: "error",
+        message: "Manifest entry declares no size, which is required \u2014 and without it the entry is excluded from the 16 MiB total and its length cannot be cross-checked.",
+        resourceUri: resource.uri
+      });
+    } else if (!isUsableSize(resource.size)) {
+      issues.push({
+        code: "malformed-size",
+        severity: "error",
+        message: `Size ${resource.size} is not a non-negative integer byte length.`,
+        resourceUri: resource.uri
+      });
+    }
+  }
+  return issues;
+}
+function isUsableSize(size) {
+  return size !== void 0 && Number.isSafeInteger(size) && size >= 0;
+}
+function totalSkillBytes(resources) {
+  return resources.reduce(
+    (sum, r) => sum + (isUsableSize(r.size) ? r.size : 0),
+    0
+  );
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value === null || typeof value !== "object") return value;
+  return sortKeys(value);
+}
+function sortKeys(value) {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, member]) => [key, canonicalize(member)]).sort(([x], [y]) => x.localeCompare(y))
+  );
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+async function sha256Digest(bytes) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) return `sha256:${toHex(sha256Bytes(bytes))}`;
+  const copy = new Uint8Array(bytes);
+  const hash = await subtle.digest("SHA-256", copy.buffer);
+  return `sha256:${toHex(new Uint8Array(hash))}`;
+}
+function textToBytes(text) {
+  return new TextEncoder().encode(text);
+}
+function bytesToText(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function base64ToBytes(blob) {
+  const binary = atob(blob);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function skillFileBytes(contents) {
+  if (typeof contents.text === "string") return textToBytes(contents.text);
+  if (typeof contents.blob === "string") return base64ToBytes(contents.blob);
+  throw new Error("resources/read returned neither text nor blob content.");
+}
+async function verifySkillResource(resource, bytes) {
+  const expectedSize = resource.size;
+  if (expectedSize !== void 0 && expectedSize !== bytes.byteLength) {
+    return {
+      status: "mismatch",
+      expectedSize,
+      actualSize: bytes.byteLength,
+      ...resource.digest !== void 0 ? { expectedDigest: resource.digest } : {},
+      reason: `Manifest declares ${expectedSize} bytes but the fetched file is ${bytes.byteLength}.`
+    };
+  }
+  const expectedDigest = resource.digest;
+  if (expectedDigest === void 0) {
+    return {
+      status: "unverifiable",
+      reason: "The manifest entry advertises no digest."
+    };
+  }
+  if (!DIGEST_PATTERN.test(expectedDigest)) {
+    return {
+      status: "unverifiable",
+      expectedDigest,
+      reason: 'The advertised digest is not "sha256:" followed by 64 lowercase hex characters.'
+    };
+  }
+  const actualDigest = await sha256Digest(bytes);
+  return {
+    status: actualDigest === expectedDigest ? "verified" : "mismatch",
+    actualDigest,
+    expectedDigest,
+    ...expectedSize !== void 0 ? { expectedSize, actualSize: bytes.byteLength } : {}
+  };
+}
+function jsonLikeEqual(a, b) {
+  if (typeof a === "number" || typeof b === "number") {
+    if (typeof a === "number" && typeof b === "number") {
+      return Number.isFinite(a) && Number.isFinite(b) ? a === b : Object.is(a, b);
+    }
+    return false;
+  }
+  if (a === null || b === null) return a === b;
+  if (typeof a !== "object" || typeof b !== "object") return Object.is(a, b);
+  const aArray = Array.isArray(a);
+  if (aArray !== Array.isArray(b)) return false;
+  if (aArray) {
+    const x2 = a;
+    const y2 = b;
+    return x2.length === y2.length && x2.every((v, i) => jsonLikeEqual(v, y2[i]));
+  }
+  const x = a;
+  const y = b;
+  const keys = Object.keys(x);
+  return keys.length === Object.keys(y).length && keys.every((k) => Object.hasOwn(y, k) && jsonLikeEqual(x[k], y[k]));
+}
+function displayValue(value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  return JSON.stringify(
+    canonicalize(value),
+    (_key, member) => typeof member === "number" && !Number.isFinite(member) ? `<${String(member)}>` : member
+  );
+}
+function checkSkillFrontmatterMatch(entry, skillFileText) {
+  const { frontmatter } = splitSkillFile(skillFileText);
+  if (frontmatter === void 0) {
+    return [
+      {
+        code: "frontmatter-absent",
+        severity: "error",
+        message: "The served SKILL.md carries no YAML frontmatter block, so the listing's frontmatter cannot be the file's.",
+        resourceUri: entry.uri
+      }
+    ];
+  }
+  const listedError = jsonGraphError(entry.frontmatter);
+  if (listedError) {
+    return [
+      {
+        code: "frontmatter-unparsable",
+        severity: "error",
+        message: `The listing's own frontmatter cannot be compared: ${listedError}`,
+        resourceUri: entry.uri
+      }
+    ];
+  }
+  const parsed = parseSkillFrontmatter(frontmatter);
+  if ("error" in parsed) {
+    return [
+      {
+        code: "frontmatter-unparsable",
+        severity: "error",
+        message: `The served SKILL.md's frontmatter is not valid YAML: ${parsed.error}`,
+        resourceUri: entry.uri
+      }
+    ];
+  }
+  const issues = [];
+  const fields = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(entry.frontmatter),
+      ...Object.keys(parsed.fields)
+    ])
+  ].sort();
+  for (const field of fields) {
+    const listed = entry.frontmatter[field];
+    const served = parsed.fields[field];
+    if (listed === void 0) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `The served SKILL.md declares "${field}" but the listing's frontmatter omits it.`,
+        resourceUri: entry.uri
+      });
+      continue;
+    }
+    if (served === void 0) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `The listing declares "${field}" but the served SKILL.md omits it.`,
+        resourceUri: entry.uri
+      });
+      continue;
+    }
+    if (!jsonLikeEqual(listed, served)) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `Field "${field}" differs: the listing says ${displayValue(listed)} but the served SKILL.md says ${displayValue(served)}.`,
+        resourceUri: entry.uri
+      });
+    }
+  }
+  return issues;
+}
+var COLLISION_SAMPLE = 3;
+function checkSkillNameCollisions(entries) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const name = entry.frontmatter.name;
+    if (typeof name !== "string" || name.trim() === "") continue;
+    const group = byName.get(name);
+    if (group) group.push(entry);
+    else byName.set(name, [entry]);
+  }
+  const issues = /* @__PURE__ */ new Map();
+  for (const [name, group] of byName) {
+    const identities = new Set(group.map((e) => skillUriIdentity(e.uri)));
+    if (identities.size < 2) continue;
+    const uris = [...identities].sort();
+    for (const entry of group) {
+      const self = skillUriIdentity(entry.uri);
+      const sample = [];
+      for (const uri of uris) {
+        if (uri === self) continue;
+        sample.push(uri);
+        if (sample.length === COLLISION_SAMPLE) break;
+      }
+      const unshown = identities.size - 1 - sample.length;
+      const others = unshown > 0 ? `${sample.join(", ")}, and ${unshown} more` : sample.join(", ");
+      const subject = identities.size === 2 ? "Another skill in this listing also declares" : `${identities.size - 1} other skills in this listing also declare`;
+      issues.set(self, {
+        code: "duplicate-name",
+        severity: "warning",
+        message: `${subject} the name "${name}" (${others}). This is legal \u2014 a consumer must tell them apart by their URIs rather than collapsing or preferring one.`
+      });
+    }
+  }
+  return issues;
+}
+
 // ../../core/mcp/appElicitation.ts
 import { ElicitResultSchema } from "@modelcontextprotocol/core";
 function uiExtension(capabilities) {
@@ -5065,7 +5720,7 @@ import {
   ListResourcesResultSchema,
   ListResourceTemplatesResultSchema,
   ListPromptsResultSchema,
-  ResourceSchema,
+  ResourceSchema as ResourceSchema2,
   ResourceTemplateSchema,
   PromptSchema
 } from "@modelcontextprotocol/core";
@@ -5088,7 +5743,7 @@ function validateToolOutput(provider, tool, result) {
 }
 
 // ../../core/mcp/listSalvage.ts
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
 import { SdkError as SdkError2, SdkErrorCode as SdkErrorCode2 } from "@modelcontextprotocol/client";
 import { ToolSchema } from "@modelcontextprotocol/core";
 var LIST_MAX_PAGES = 64;
@@ -5104,20 +5759,20 @@ function isSalvageableRejection(err) {
   return SdkError2.isInstance(err) && err.code === SdkErrorCode2.InvalidResult;
 }
 function lenientListPageSchema(resultSchema, itemsKey) {
-  return resultSchema.extend({ [itemsKey]: z2.array(z2.unknown()) });
+  return resultSchema.extend({ [itemsKey]: z3.array(z3.unknown()) });
 }
 function nextCursorOf(page) {
   if (typeof page !== "object" || page === null) return void 0;
   const value = page.nextCursor;
   return typeof value === "string" ? value : void 0;
 }
-var ModernResultEnvelopeSchema = z2.looseObject({
-  resultType: z2.literal("complete"),
+var ModernResultEnvelopeSchema = z3.looseObject({
+  resultType: z3.literal("complete"),
   // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
   // envelope violation the strict path rejects, and accepting it here on the
   // strength of an unrelated bad entry would hide it.
-  ttlMs: z2.int().min(0),
-  cacheScope: z2.enum(["public", "private"])
+  ttlMs: z3.int().min(0),
+  cacheScope: z3.enum(["public", "private"])
 });
 function rawItemsOf(page, itemsKey) {
   if (typeof page !== "object" || page === null) return void 0;
@@ -5186,9 +5841,9 @@ var LegacyToolWireSchema = ToolSchema.extend({
   outputSchema: ToolSchema.shape.inputSchema.optional()
 });
 var ModernToolWireSchema = ToolSchema.extend({
-  inputSchema: z2.looseObject({
-    type: z2.literal("object"),
-    $schema: z2.string().optional()
+  inputSchema: z3.looseObject({
+    type: z3.literal("object"),
+    $schema: z3.string().optional()
   })
 });
 function stripExecution(tool) {
@@ -5202,10 +5857,10 @@ function eraToolItemSchema(wire, normalize) {
 
 // ../../core/mcp/taskNotificationSchemas.ts
 import { NotificationSchema } from "@modelcontextprotocol/core";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 var TasksListChangedNotificationSchema = NotificationSchema.extend({
-  method: z3.literal("notifications/tasks/list_changed"),
-  params: z3.record(z3.string(), z3.unknown()).optional()
+  method: z4.literal("notifications/tasks/list_changed"),
+  params: z4.record(z4.string(), z4.unknown()).optional()
 });
 
 // ../../core/mcp/uriTemplate.ts
@@ -6186,8 +6841,8 @@ var BaseOAuthClientProvider = class {
     );
   }
   async saveClientInformation(clientInformation, options) {
-    const registrationKind = options && "registrationKind" in options ? options.registrationKind : "dcr";
     const issuer = options && "issuer" in options ? options.issuer : void 0;
+    const registrationKind = options && "registrationKind" in options ? options.registrationKind : await this.resolveSdkRegistrationKind(clientInformation, issuer);
     await this.storage.saveClientInformation(
       this.serverUrl,
       clientInformation,
@@ -6197,6 +6852,70 @@ var BaseOAuthClientProvider = class {
       }
     );
   }
+  /**
+   * Resolve the registration kind for a save that carries no explicit one — that
+   * is, one the SDK made. SDK v2's `saveClientInformation` contract passes only
+   * `{ issuer }`, so the mechanism cannot be handed to us; treating every such
+   * save as DCR is what relabeled a CIMD registration `Dynamic (DCR)` in
+   * Connection Info the moment the SDK bound it to an issuer (#2242).
+   *
+   * Two cases reach here, and they are told apart by whether a registration
+   * already exists for this issuer:
+   *
+   * - **A back-stamp.** A registration is already stored for this issuer under
+   *   this `client_id`, and the SDK is only adding the `issuer` to it. Its
+   *   recorded kind is the answer — kind and credential are written and cleared
+   *   together, so a stored registration always has one.
+   * - **A new registration.** Nothing is stored for this issuer, so this save
+   *   creates it. SDK v2 `auth()` reaches its URL-based-client-ID branch — rather
+   *   than `registerClient` — exactly when the AS advertises
+   *   `client_id_metadata_document_supported` and a `clientMetadataUrl` is
+   *   configured, and it persists the AS metadata via `saveDiscoveryState`
+   *   *before* it reads or writes client information. So the branch it took is
+   *   not inferred here, it is read back from the state it just wrote.
+   *
+   * This is why the check is not "the `client_id` looks like our metadata URL".
+   * RFC 7591 §3.2 makes a dynamically issued `client_id` opaque, so an AS may
+   * mint that very URL from `POST /register`; the URL comparison only decides
+   * whether CIMD is *in play* for this connection, and the two cases above decide
+   * what actually happened (#2242, Copilot).
+   *
+   * Consequences worth stating, since each was a defect on the way here:
+   *
+   * - An existing DCR whose `client_id` happens to be the metadata URL stays
+   *   `dcr` — it takes the back-stamp path and its recorded kind says so.
+   * - `invalidateCredentials("client")`, which SDK `auth()` calls on
+   *   `invalid_client` before retrying, clears the registration and its kind. The
+   *   retry therefore takes the new-registration path and is answered from
+   *   discovery state, which that clear does not touch.
+   * - A second AS behind one resource gets its own answer, since discovery state
+   *   describes the issuer the SDK actually resolved. One that does not advertise
+   *   CIMD is `dcr` even when it mints the metadata URL as its `client_id`.
+   * - A transient failure in our own CIMD preflight costs nothing: the SDK's own
+   *   discovery is what this reads.
+   */
+  async resolveSdkRegistrationKind(clientInformation, issuer) {
+    const clientMetadataUrl = this.clientMetadataUrl?.trim();
+    if (!clientMetadataUrl || clientInformation.client_id !== clientMetadataUrl) {
+      return "dcr";
+    }
+    const stored = await this.storage.getClientInformation(
+      this.serverUrl,
+      false,
+      issuer
+    );
+    if (stored?.client_id === clientMetadataUrl) {
+      const storedKind = await this.storage.getClientRegistrationKind(
+        this.serverUrl,
+        issuer
+      );
+      return storedKind === "cimd" ? "cimd" : "dcr";
+    }
+    const discovery = await this.storage.getDiscoveryState(this.serverUrl);
+    const metadata = discovery?.authorizationServerMetadata;
+    if (issuer !== void 0 && metadata?.issuer !== issuer) return "dcr";
+    return metadata?.client_id_metadata_document_supported === true ? "cimd" : "dcr";
+  }
   async saveScope(scope) {
     await this.storage.saveScope(this.serverUrl, scope);
     this.cachedScope = scope;
@@ -7075,35 +7794,49 @@ import { discoverOAuthProtectedResourceMetadata as discoverOAuthProtectedResourc
 async function ensureCimdClientRegistration(params) {
   const clientMetadataUrl = params.provider.clientMetadataUrl?.trim();
   if (!clientMetadataUrl) return;
-  const existing = await params.provider.clientInformation();
-  if (existing?.client_id) return;
-  let resourceMetadata;
-  try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata2(
-      params.serverUrl,
-      { resourceMetadataUrl: params.resourceMetadataUrl },
-      // The same fetch the AS-metadata leg below uses. On web that is
-      // `createRemoteFetch`, which proxies through the backend to sidestep
-      // CORS — on the global `fetch` this leg would fail in the browser, be
-      // swallowed by the catch, and leave CIMD probing the wrong
-      // authorization server (Copilot).
-      params.fetchFn
-    );
-  } catch {
-    resourceMetadata = void 0;
+  let metadata = (await params.provider.discoveryState())?.authorizationServerMetadata;
+  if (!metadata) {
+    let resourceMetadata;
+    try {
+      resourceMetadata = await discoverOAuthProtectedResourceMetadata2(
+        params.serverUrl,
+        { resourceMetadataUrl: params.resourceMetadataUrl },
+        // The same fetch the AS-metadata leg below uses. On web that is
+        // `createRemoteFetch`, which proxies through the backend to sidestep
+        // CORS — on the global `fetch` this leg would fail in the browser, be
+        // swallowed by the catch, and leave CIMD probing the wrong
+        // authorization server (Copilot).
+        params.fetchFn
+      );
+    } catch {
+      resourceMetadata = void 0;
+    }
+    try {
+      metadata = await discoverAuthorizationServerMetadataForServer(
+        params.serverUrl,
+        resourceMetadata,
+        params.fetchFn
+      );
+    } catch {
+      return;
+    }
   }
-  const metadata = await discoverAuthorizationServerMetadataForServer(
-    params.serverUrl,
-    resourceMetadata,
-    params.fetchFn
-  );
+  const issuer = metadata?.issuer;
   if (!metadata?.client_id_metadata_document_supported) return;
-  const clientInformation = {
-    client_id: clientMetadataUrl
-  };
-  await params.provider.saveClientInformation(clientInformation, {
-    registrationKind: "cimd"
-  });
+  const existing = await params.provider.clientInformation(
+    issuer ? { issuer } : void 0
+  );
+  if (existing?.client_id) return;
+  await params.provider.saveClientInformation(
+    { client_id: clientMetadataUrl },
+    {
+      registrationKind: "cimd",
+      // An AS metadata document without an `issuer` is malformed (RFC 8414 §2),
+      // but the type allows it; fall back to the unkeyed slot rather than
+      // inventing a key.
+      ...issuer && { issuer }
+    }
+  );
 }
 
 // ../../core/auth/ema/transportProvider.ts
@@ -7130,11 +7863,26 @@ var EmaTransportOAuthProvider = class {
   state() {
     return this.inner.state();
   }
-  clientInformation() {
-    return this.inner.clientInformation();
+  // SEP-2352: `ctx` carries the authorization-server `issuer` the SDK resolved,
+  // and the inner provider keys registrations by it. Dropping it here made every
+  // EMA read and write land on the unkeyed slot — and, since #2242, left
+  // `resolveSdkRegistrationKind` with no issuer to check, so a CIMD registration
+  // made over an EMA connection was recorded as DCR (Copilot).
+  clientInformation(ctx) {
+    return this.inner.clientInformation(ctx);
+  }
+  saveClientInformation(clientInformation, ctx) {
+    return this.inner.saveClientInformation(clientInformation, ctx);
   }
-  saveClientInformation(clientInformation) {
-    return this.inner.saveClientInformation(clientInformation);
+  // Without these the SDK persists no discovery state for an EMA connection, so
+  // it re-discovers on every call, cannot perform its SEP-2352 callback-leg
+  // authorization-server binding check (it warns as much), and — since #2242 —
+  // leaves the registration-kind resolver nothing to read back.
+  saveDiscoveryState(state) {
+    return this.inner.saveDiscoveryState(state);
+  }
+  discoveryState() {
+    return this.inner.discoveryState();
   }
   async tokens() {
     const stored = await this.inner.tokens();
@@ -7203,8 +7951,11 @@ function issuerMismatchTitle() {
   return "Authorization server mismatch";
 }
 var MAX_DISPLAYED_ISSUER_LENGTH = 120;
+function truncateUrlForDisplay(url) {
+  return url.length > MAX_DISPLAYED_ISSUER_LENGTH ? `${url.slice(0, MAX_DISPLAYED_ISSUER_LENGTH)}\u2026` : url;
+}
 function truncateIssuerForDisplay(issuer) {
-  return issuer.length > MAX_DISPLAYED_ISSUER_LENGTH ? `${issuer.slice(0, MAX_DISPLAYED_ISSUER_LENGTH)}\u2026` : issuer;
+  return truncateUrlForDisplay(issuer);
 }
 function issuerMismatchMessage(options) {
   const target = options.serverName ? `"${options.serverName}"` : "this server";
@@ -10418,7 +11169,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       throw new Error("Client is not connected");
     }
     const result = await this.client.request(
-      { method: "tasks/list", params: cursor ? { cursor } : {} },
+      {
+        method: "tasks/list",
+        // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+        // legal value a server may hand back. Dropping it asks for page one
+        // again, so a caller walking pages would loop on the first page.
+        params: cursor !== void 0 ? { cursor } : {}
+      },
       ListTasksResultSchema,
       this.getRequestOptions()
     );
@@ -12012,7 +12769,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -12040,7 +12800,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       method: "resources/list",
       itemsKey: "resources",
       resultSchema: ListResourcesResultSchema,
-      itemSchema: ResourceSchema,
+      itemSchema: ResourceSchema2,
       metadata: options?.metadata,
       aggregate: async () => [
         ...(await this.client.listResources(
@@ -12142,7 +12902,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -12195,7 +12958,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -12234,6 +13000,155 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     });
     return { prompts };
   }
+  /**
+   * The Skills extension (SEP-2640) the server declared, or `undefined` when it
+   * declared none. Gates the Skills tab and the skills store the same way
+   * {@link isTasksExtensionNegotiated} gates Tasks — but deliberately without an
+   * era check: `skills/*` are not spec method names in either codec, so a
+   * legacy-era server that declares the extension is serving it (#2234).
+   */
+  getSkillsExtension() {
+    return getSkillsExtension(this.capabilities);
+  }
+  /**
+   * One page of `skills/list` (SEP-2640).
+   *
+   * An ordinary `client.request` with an explicit result schema — the SDK's era
+   * gate skips methods neither codec defines, and `assertCapabilityForMethod`
+   * falls through to a no-op for them, so this is all the extension needs. The
+   * raw-wire path modern `tasks/*` uses would be wrong here: it exists for spec
+   * names the 2026 codec deleted, and taking it would bypass the SDK's response
+   * correlation for nothing (#2234).
+   */
+  async listSkills(cursor, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      ...effectiveMeta ? { _meta: effectiveMeta } : {},
+      // `!== undefined`, not truthiness: a cursor is opaque and the empty
+      // string is a legal value. Dropping `""` would silently re-request page
+      // one, which the store then reports as a repeated-cursor failure — a
+      // conforming server made to look broken.
+      ...cursor !== void 0 ? { cursor } : {}
+    };
+    const resultSchema = this.isModernEra() ? ModernListSkillsResultSchema : ListSkillsResultSchema;
+    const response = await this.invokeMcpClient(
+      () => this.client.request(
+        { method: SKILLS_LIST_METHOD, params },
+        resultSchema,
+        this.getRequestOptions(this.progressTokenOf(metadata))
+      ),
+      { method: SKILLS_LIST_METHOD }
+    );
+    return {
+      skills: response.skills,
+      nextCursor: response.nextCursor
+    };
+  }
+  /**
+   * One skill entry by URI (`skills/get`, SEP-2640). The result envelope is
+   * required — `GetSkillEnvelopeSchema` requires `{ skill }` and rejects an entry
+   * returned inline, so a non-conforming shape fails here rather than being
+   * silently normalized past the conformance checks.
+   */
+  async getSkill(uri, metadata) {
+    return (await this.getSkillResult(uri, metadata)).skill;
+  }
+  /**
+   * `skills/get` as the server sent it — the `{ skill }` envelope **and any
+   * other members it carried**.
+   *
+   * Separate from {@link getSkill} because the callers differ: the UIs want the
+   * entry, while the CLI prints the result and must not reshape it. SEP-2640
+   * explicitly leaves open whether this result carries `ttlMs` / `cacheScope`,
+   * so a server may send them — and unwrapping to the entry discards exactly
+   * those (Copilot).
+   */
+  async getSkillResult(uri, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      uri,
+      ...effectiveMeta ? { _meta: effectiveMeta } : {}
+    };
+    const resultSchema = this.isModernEra() ? ModernGetSkillEnvelopeSchema : GetSkillEnvelopeSchema;
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: SKILLS_GET_METHOD, params },
+          resultSchema,
+          this.getRequestOptions(this.progressTokenOf(metadata))
+        ),
+        { method: SKILLS_GET_METHOD }
+      );
+    } catch (err) {
+      if (isClientDecodeRejection(err)) {
+        this.markResponseRejected(
+          SKILLS_GET_METHOD,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+      throw err;
+    }
+  }
+  /**
+   * One page of `resources/directory/read` (SEP-2640): the direct children of
+   * a directory resource.
+   *
+   * **Gated on the server's own declaration, and the gate throws rather than
+   * asks.** SEP-2640 is explicit that *"clients MUST NOT call
+   * `resources/directory/read` against a server that has not declared
+   * `directoryRead: true`"*, so this refuses locally instead of sending a call
+   * the spec forbids and letting the server answer `-32601`. Refusing here also
+   * keeps the Protocol tab honest: a request we were never allowed to make
+   * should not appear in the exchange log as a server-side failure.
+   *
+   * Not recursive — the SEP says clients descend by calling the method again on
+   * a child directory, so the walking is the caller's, not this method's.
+   */
+  async readResourceDirectory(uri, cursor, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const extension = this.getSkillsExtension();
+    if (!extension?.directoryRead) {
+      throw new Error(
+        `Server did not declare directoryRead in ${SKILLS_EXTENSION_KEY}; ${RESOURCES_DIRECTORY_READ_METHOD} must not be called.`
+      );
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      uri,
+      ...effectiveMeta ? { _meta: effectiveMeta } : {},
+      // `!== undefined` for the same reason `listSkills` uses it: a cursor is
+      // opaque and `""` is a legal value, so truthiness would silently re-ask
+      // for page one.
+      ...cursor !== void 0 ? { cursor } : {}
+    };
+    const resultSchema = this.isModernEra() ? ModernDirectoryReadResultSchema : DirectoryReadResultSchema;
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: RESOURCES_DIRECTORY_READ_METHOD, params },
+          resultSchema,
+          this.getRequestOptions(this.progressTokenOf(metadata))
+        ),
+        { method: RESOURCES_DIRECTORY_READ_METHOD }
+      );
+    } catch (err) {
+      if (isClientDecodeRejection(err)) {
+        this.markResponseRejected(
+          RESOURCES_DIRECTORY_READ_METHOD,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+      throw err;
+    }
+  }
   /**
    * Get a prompt by name
    * @param name Prompt name
@@ -13259,7 +14174,30 @@ var EXIT_CODES = {
   AUTH_REQUIRED: 3,
   UNREACHABLE: 4,
   TOOL_ERROR: 5,
-  SCHEMA_UNPORTABLE: 6
+  SCHEMA_UNPORTABLE: 6,
+  /**
+   * `--verify` found a SEP-2640 violation: a conformance error, a digest or
+   * size mismatch, or a manifest file that could not be read (#2248).
+   *
+   * Its own code rather than reusing `SCHEMA_UNPORTABLE`, for the reason that
+   * one exists at all: a CI job that fails on an unportable tool schema and a
+   * CI job that fails on a tampered skill digest are different jobs, and
+   * collapsing them would make `if [ $? -eq 6 ]` ambiguous.
+   */
+  SKILL_NONCONFORMANT: 7,
+  /**
+   * `--verify` could not check the whole catalog: the read bounds stopped the
+   * walk before it finished (#2248).
+   *
+   * Distinct from `SKILL_NONCONFORMANT` because the server has broken no
+   * **MUST** — SEP-2640 states the 512-entry and 16 MiB limits as SHOULD NOT,
+   * with hosts free to support more — so exiting 7 would call a conforming
+   * server nonconformant. It is still non-zero, because reporting success for
+   * a manifest whose unread entries were never fetched is a false pass. A CI
+   * job that wants to tolerate oversized catalogs can allow 8 and still fail
+   * on 7.
+   */
+  SKILL_INCOMPLETE: 8
 };
 var CliExitCodeError = class extends Error {
   constructor(exitCode, message, envelope) {
@@ -13767,6 +14705,15 @@ async function consumeMethodOutcome(outcome, args) {
     for (const line of outcome.lines) {
       await awaitableLog(JSON.stringify(line) + "\n");
     }
+    if (outcome.summary) await awaitableError(`${outcome.summary}
+`);
+    if (outcome.exitCode) {
+      throw new CliExitCodeError(outcome.exitCode, outcome.summary ?? "", {
+        // The envelope's `code` follows the exit code, so a caller reading one
+        // never has to reconcile it against the other.
+        code: outcome.exitCode === EXIT_CODES.SKILL_INCOMPLETE ? "skills_incomplete" : "skills_nonconformant"
+      });
+    }
     return;
   }
   await new Promise((resolve7) => {
@@ -14332,7 +15279,7 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
       const page = result.tasks.filter((t) => !this.dismissedTaskIds.has(t.taskId)).map(
         (t) => this.cancelledTaskIds.has(t.taskId) ? { ...t, status: "cancelled" } : t
       );
-      this.tasks = cursor ? [...this.tasks, ...page] : page;
+      this.tasks = cursor === void 0 ? page : [...this.tasks, ...page];
       cursor = result.nextCursor;
       pageCount++;
       if (pageCount >= MAX_PAGES) {
@@ -14340,7 +15287,7 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
           `Maximum pagination limit (${MAX_PAGES} pages) reached while listing requestor tasks`
         );
       }
-    } while (cursor);
+    } while (cursor !== void 0);
     this.dispatchTypedEvent("tasksChange", this.tasks);
     return this.getTasks();
   }
@@ -14393,6 +15340,146 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
   }
 };
 
+// ../../core/mcp/state/managedSkillsState.ts
+var REPEATED_CURSOR_MESSAGE = "Server repeated a pagination cursor in skills/list; stopped to avoid an infinite walk.";
+var SKILLS_MAX_PAGES = LIST_MAX_PAGES;
+var SKILLS_PAGE_LIMIT_MESSAGE = `skills/list exceeded ${SKILLS_MAX_PAGES} pages without the server's pagination converging`;
+var ManagedSkillsState = class extends TypedEventTarget {
+  skills = [];
+  pageCount = 0;
+  error = null;
+  client = null;
+  unsubscribe = null;
+  // Overlap guard, held as the generation whose walk is in flight (or `null`).
+  // See `refresh` for why this is not a boolean.
+  runningGeneration = null;
+  // Session counter, advanced by `reset` (disconnect) and by `destroy`. A walk
+  // captures it and abandons its writes when it no longer matches.
+  generation = 0;
+  constructor(client) {
+    super();
+    this.client = client;
+    const onConnect = () => {
+      void this.refresh().catch(() => {
+      });
+    };
+    const onStatusChange = () => {
+      if (isTerminalStatus(this.client?.getStatus())) {
+        this.reset();
+      }
+    };
+    this.client.addEventListener("connect", onConnect);
+    this.client.addEventListener("statusChange", onStatusChange);
+    this.unsubscribe = () => {
+      if (this.client) {
+        this.client.removeEventListener("connect", onConnect);
+        this.client.removeEventListener("statusChange", onStatusChange);
+      }
+      this.client = null;
+    };
+  }
+  /** Defensive copy of the current list. */
+  getSkills() {
+    return [...this.skills];
+  }
+  getPagination() {
+    return { pageCount: this.pageCount };
+  }
+  /** The last walk's failure, or `null` when it succeeded. */
+  getError() {
+    return this.error;
+  }
+  // Compared by identity rather than message: two distinct failures with the
+  // same text are still two events, and a re-render on a repeat failure is
+  // cheap next to silently coalescing them.
+  setError(value) {
+    if (this.error === value) return;
+    this.error = value;
+    this.dispatchTypedEvent("errorChange", value);
+  }
+  reset() {
+    this.generation += 1;
+    this.skills = [];
+    this.pageCount = 0;
+    this.dispatchTypedEvent("skillsChange", this.getSkills());
+    this.dispatchTypedEvent("paginationChange", this.getPagination());
+    this.setError(null);
+  }
+  /**
+   * Walk every page of `skills/list` and commit the result.
+   *
+   * A failure is recorded as observable state (`getError`) AND re-thrown: the
+   * state drives the panel's error rendering, while the rejection is what a
+   * caller's auth-recovery wrapper keys off to detect a 401 and start a
+   * re-authorization. The connect-time load, which has no such caller, catches
+   * it above.
+   */
+  async refresh(metadata) {
+    const client = this.client;
+    if (!client || client.getStatus() !== "connected") return this.getSkills();
+    if (!client.getSkillsExtension()) {
+      this.applyPages([], 0);
+      return this.getSkills();
+    }
+    const generation = this.generation;
+    const isCurrent = () => this.generation === generation;
+    if (this.runningGeneration === generation) return this.getSkills();
+    this.runningGeneration = generation;
+    try {
+      const collected = [];
+      const seen = /* @__PURE__ */ new Set();
+      let cursor;
+      let pages = 0;
+      for (; ; ) {
+        const page = await client.listSkills(cursor, metadata);
+        if (!isCurrent()) return this.getSkills();
+        collected.push(...page.skills);
+        pages += 1;
+        if (page.nextCursor === void 0) break;
+        if (pages >= SKILLS_MAX_PAGES) {
+          throw new Error(SKILLS_PAGE_LIMIT_MESSAGE);
+        }
+        if (seen.has(page.nextCursor)) {
+          throw new Error(REPEATED_CURSOR_MESSAGE);
+        }
+        seen.add(page.nextCursor);
+        cursor = page.nextCursor;
+      }
+      this.setError(null);
+      this.applyPages(collected, pages);
+      return this.getSkills();
+    } catch (err) {
+      if (isCurrent()) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.setError(error);
+        if (isClientDecodeRejection(err)) {
+          client.markResponseRejected?.(SKILLS_LIST_METHOD, error.message);
+        }
+      }
+      throw err;
+    } finally {
+      if (this.runningGeneration === generation) {
+        this.runningGeneration = null;
+      }
+    }
+  }
+  applyPages(skills, pageCount) {
+    this.skills = skills;
+    this.pageCount = pageCount;
+    this.dispatchTypedEvent("skillsChange", this.getSkills());
+    this.dispatchTypedEvent("paginationChange", this.getPagination());
+  }
+  /** Unsubscribe from the client and drop the list; idempotent. */
+  destroy() {
+    this.generation += 1;
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.skills = [];
+    this.pageCount = 0;
+    this.error = null;
+  }
+};
+
 // ../../core/mcp/apps.ts
 import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
 function getAppResourceUri(tool) {
@@ -14463,13 +15550,241 @@ async function collectAppInfo(client, tool, metadata) {
   }
 }
 
+// src/handlers/skills-verify.ts
+function summarizeSkillVerification(reports) {
+  const failed = reports.filter((report) => report.outcome === "failed").length;
+  const incomplete = reports.filter(
+    (report) => report.outcome === "incomplete"
+  ).length;
+  const files = reports.reduce((sum, report) => sum + report.files.length, 0);
+  const mismatched = reports.reduce(
+    (sum, report) => sum + report.files.filter((file) => file.status === "mismatch").length,
+    0
+  );
+  const skillWord = reports.length === 1 ? "skill" : "skills";
+  const fileWord = files === 1 ? "file" : "files";
+  const incompleteClause = incomplete === 0 ? "" : ` ${incomplete} of ${reports.length} ${skillWord} could not be fully checked: the read bounds stopped the walk.`;
+  const headline = failed === 0 ? incomplete === 0 ? `Verified ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors.` : `Checked ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors in what was read.` : `${failed} of ${reports.length} ${skillWord} failed verification (${mismatched} digest/size mismatch across ${files} ${fileWord}).`;
+  return `${headline}${incompleteClause}`;
+}
+
+// ../../core/mcp/skillsVerification.ts
+function reasonOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function boundedManifest(declared) {
+  const kept = [];
+  let bytes = 0;
+  for (const resource of declared) {
+    if (kept.length >= SKILL_MAX_RESOURCE_ENTRIES) break;
+    const size = typeof resource.size === "number" && Number.isSafeInteger(resource.size) && resource.size >= 0 ? resource.size : 0;
+    if (bytes + size > SKILL_MAX_TOTAL_BYTES) break;
+    bytes += size;
+    kept.push(resource);
+  }
+  return kept;
+}
+function contentsFor(result, uri) {
+  const contents = result?.contents;
+  if (!Array.isArray(contents)) return void 0;
+  const wanted = skillUriIdentity(uri);
+  for (const block of contents) {
+    if (typeof block !== "object" || block === null) continue;
+    const got = block.uri;
+    if (typeof got !== "string") continue;
+    if (skillUriIdentity(got) === wanted) return block;
+  }
+  return void 0;
+}
+function utf8Length(value) {
+  let total = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 128) {
+      total += 1;
+    } else if (code < 2048) {
+      total += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = i + 1 < value.length ? value.charCodeAt(i + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        total += 4;
+        i += 1;
+      } else {
+        total += 3;
+      }
+    } else {
+      total += 3;
+    }
+  }
+  return total;
+}
+function responseBytes(result) {
+  const contents = result?.contents;
+  if (!Array.isArray(contents)) return 0;
+  let total = 0;
+  for (const block of contents) {
+    if (typeof block !== "object" || block === null) continue;
+    const { text, blob } = block;
+    if (typeof text === "string") total += utf8Length(text);
+    if (typeof blob === "string") total += blob.length;
+  }
+  return total;
+}
+async function verifySkills(client, entries, metadata) {
+  const collisions = checkSkillNameCollisions(entries);
+  const reports = [];
+  let walkedSkills = 0;
+  let catalogBytes = 0;
+  for (const entry of entries) {
+    const withinBudget = walkedSkills < SKILL_MAX_CATALOG_SKILLS && catalogBytes <= SKILL_MAX_CATALOG_BYTES;
+    let entryBytes;
+    const files = [];
+    const declared = entry.resources === DYNAMIC_RESOURCES ? [] : entry.resources;
+    const manifest = withinBudget ? boundedManifest(declared) : [];
+    let incomplete = !withinBudget ? `Not read: this run already reached its catalog budget of ${SKILL_MAX_CATALOG_SKILLS} skills / ${SKILL_MAX_CATALOG_BYTES} bytes. Nothing about this skill's files has been checked \u2014 verify it on its own with \`--method skills/get --uri\` to get a verdict.` : manifest.length < declared.length ? `Only ${manifest.length} of ${declared.length} manifest entries were read: the skill exceeds the ${SKILL_MAX_RESOURCE_ENTRIES}-entry / ${SKILL_MAX_TOTAL_BYTES}-byte interoperability limits, so the rest were not fetched and cannot be reported on.` : void 0;
+    let receivedBytes = 0;
+    const entryIdentity = skillUriIdentity(entry.uri);
+    let selfAttempted = false;
+    for (const [index, resource] of manifest.entries()) {
+      if (skillUriIdentity(resource.uri) === entryIdentity) {
+        selfAttempted = true;
+      }
+      let charged = 0;
+      try {
+        const invocation = await client.readResource(resource.uri, metadata);
+        charged = responseBytes(invocation.result);
+        const contents = contentsFor(invocation.result, resource.uri);
+        if (!contents) {
+          files.push({
+            uri: resource.uri,
+            status: "read-error",
+            reason: "resources/read returned no content block for this URI, so there are no bytes that can be checked against its digest."
+          });
+        } else {
+          let bytes;
+          try {
+            bytes = skillFileBytes(contents);
+          } catch (err) {
+            files.push({
+              uri: resource.uri,
+              status: "read-error",
+              reason: reasonOf(err)
+            });
+          }
+          if (bytes) {
+            charged = Math.max(charged, bytes.byteLength);
+            if (skillUriIdentity(resource.uri) === entryIdentity)
+              entryBytes = bytes;
+            const verification = await verifySkillResource(resource, bytes);
+            files.push({ uri: resource.uri, ...verification });
+          }
+        }
+      } catch (err) {
+        if (err instanceof AuthRecoveryRequiredError) throw err;
+        files.push({
+          uri: resource.uri,
+          status: "read-error",
+          reason: reasonOf(err)
+        });
+      }
+      receivedBytes += charged;
+      if (receivedBytes > SKILL_MAX_TOTAL_BYTES) {
+        if (index < manifest.length - 1) {
+          incomplete = `Stopped after ${index + 1} of ${declared.length} manifest entries: the files actually served exceed the ${SKILL_MAX_TOTAL_BYTES}-byte interoperability limit, whatever sizes the manifest declared.`;
+        }
+        break;
+      }
+    }
+    if (withinBudget && !selfAttempted) {
+      const fail = (reason) => files.push({ uri: entry.uri, status: "read-error", reason });
+      try {
+        const invocation = await client.readResource(entry.uri, metadata);
+        const contents = contentsFor(invocation.result, entry.uri);
+        if (!contents) {
+          fail(
+            "resources/read returned no content block for this skill's own SKILL.md, so its frontmatter cannot be checked against the listing."
+          );
+        } else {
+          try {
+            entryBytes = skillFileBytes(contents);
+          } catch (err) {
+            fail(reasonOf(err));
+          }
+        }
+        const declaredSelf = declared.find(
+          (resource) => skillUriIdentity(resource.uri) === entryIdentity
+        );
+        if (declaredSelf && entryBytes !== void 0) {
+          files.push({
+            // The DECLARED spelling, not the entry's. They can differ — a
+            // manifest may write its self-entry in a normalized-equivalent
+            // form — and a consumer matching rows against the manifest then
+            // finds nothing, while a normalized "extra files" filter suppresses
+            // it as already covered. The result was a verdict that existed in
+            // the report and appeared nowhere on screen (Copilot).
+            uri: declaredSelf.uri,
+            ...await verifySkillResource(declaredSelf, entryBytes)
+          });
+        }
+      } catch (err) {
+        if (err instanceof AuthRecoveryRequiredError) throw err;
+        fail(reasonOf(err));
+      }
+    }
+    if (withinBudget) {
+      walkedSkills += 1;
+      catalogBytes += receivedBytes;
+    }
+    const entryText = entryBytes === void 0 ? void 0 : bytesToText(entryBytes);
+    const collision = collisions.get(skillUriIdentity(entry.uri));
+    const conformance = [
+      ...checkSkillConformance(entry),
+      ...collision ? [collision] : []
+    ];
+    const frontmatter = entryText === void 0 ? [] : checkSkillFrontmatterMatch(entry, entryText);
+    const hasError = [...conformance, ...frontmatter].some(
+      (issue) => issue.severity === "error"
+    );
+    const fileFailed = files.some(
+      (file) => file.status === "mismatch" || file.status === "read-error"
+    );
+    reports.push({
+      uri: entry.uri,
+      name: skillDisplayName(entry),
+      conformance,
+      frontmatter,
+      files,
+      ...incomplete ? { incomplete } : {},
+      ok: !hasError && !fileFailed,
+      outcome: hasError || fileFailed ? "failed" : incomplete !== void 0 ? "incomplete" : "verified"
+    });
+  }
+  return reports;
+}
+function allSkillsVerified(reports) {
+  return reports.every((report) => report.outcome === "verified");
+}
+function anySkillFailed(reports) {
+  return reports.some((report) => report.outcome === "failed");
+}
+
 // src/handlers/run-method.ts
+function assertSkillsSupported(inspectorClient, method) {
+  if (!inspectorClient.getSkillsExtension()) {
+    throw new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      `Server does not declare the ${SKILLS_EXTENSION_KEY} extension, so ${method} is not available.`,
+      { code: "skills_unsupported" }
+    );
+  }
+}
 async function runMethod(inspectorClient, args) {
   let managedToolsState = null;
   let managedResourcesState = null;
   let managedResourceTemplatesState = null;
   let managedPromptsState = null;
   let managedTasksState = null;
+  let managedSkillsState = null;
   try {
     let result;
     let appInfo;
@@ -14688,6 +16003,73 @@ async function runMethod(inspectorClient, args) {
       result = await inspectorClient.getRequestorTaskResult(
         args.taskId
       );
+    } else if (args.method === "skills/list") {
+      assertSkillsSupported(inspectorClient, args.method);
+      managedSkillsState = new ManagedSkillsState(inspectorClient);
+      const skills = await managedSkillsState.refresh(args.metadata);
+      if (args.verify) {
+        const reports = await verifySkills(
+          inspectorClient,
+          skills,
+          args.metadata
+        );
+        return {
+          kind: "ndjson",
+          lines: reports,
+          summary: summarizeSkillVerification(reports),
+          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
+          // read bounds cut short is 8, and everything checked and passing is
+          // 0. Collapsing the middle case into either of the others reports
+          // something untrue about the server (Copilot).
+          ...allSkillsVerified(reports) ? {} : {
+            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
+          }
+        };
+      }
+      result = { skills };
+    } else if (args.method === "skills/get") {
+      if (!args.uri) {
+        throw new Error(
+          "URI is required for skills/get method. Use --uri to specify the skill URI."
+        );
+      }
+      assertSkillsSupported(inspectorClient, args.method);
+      const envelope = await inspectorClient.getSkillResult(
+        args.uri,
+        args.metadata
+      );
+      const skill = envelope.skill;
+      if (args.verify) {
+        const reports = await verifySkills(
+          inspectorClient,
+          [skill],
+          args.metadata
+        );
+        return {
+          kind: "ndjson",
+          lines: reports,
+          summary: summarizeSkillVerification(reports),
+          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
+          // read bounds cut short is 8, and everything checked and passing is
+          // 0. Collapsing the middle case into either of the others reports
+          // something untrue about the server (Copilot).
+          ...allSkillsVerified(reports) ? {} : {
+            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
+          }
+        };
+      }
+      result = envelope;
+    } else if (args.method === "resources/directory/read") {
+      if (!args.uri) {
+        throw new Error(
+          "URI is required for resources/directory/read. Use --uri to specify the directory URI."
+        );
+      }
+      result = await inspectorClient.readResourceDirectory(
+        args.uri,
+        args.cursor,
+        args.metadata
+      );
     } else if (args.method === "roots/list") {
       result = { roots: inspectorClient.getRoots() };
     } else if (args.method === "roots/set") {
@@ -14722,6 +16104,7 @@ async function runMethod(inspectorClient, args) {
     managedResourcesState?.destroy();
     managedResourceTemplatesState?.destroy();
     managedPromptsState?.destroy();
+    managedSkillsState?.destroy();
     managedTasksState?.destroy();
   }
 }
@@ -14736,7 +16119,13 @@ var ONE_SHOT_METHODS = [
   "resources/templates/list",
   "prompts/list",
   "prompts/get",
-  "logging/setLevel"
+  "logging/setLevel",
+  // SEP-2640. All three are ordinary one-shot request/response calls — no
+  // stream, no long-lived subscription — so they belong here alongside the
+  // other list verbs rather than being reachable only from the session CLI.
+  "skills/list",
+  "skills/get",
+  "resources/directory/read"
 ];
 function isOneShotMethod(method) {
   return ONE_SHOT_METHODS.includes(method);
@@ -15181,7 +16570,7 @@ function createCliOAuthNavigation(options = {}) {
 }
 
 // ../../core/client/config-parse.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 function isAbsoluteHttpUrl(value) {
   let url;
   try {
@@ -15198,11 +16587,11 @@ function isRealHost(hostname) {
   const labels = hostname.split(".");
   return labels.length >= 2 && labels.every((label) => label !== "");
 }
-var HttpUrlStringSchema = z4.string().min(1).superRefine((val, ctx) => {
+var HttpUrlStringSchema = z5.string().min(1).superRefine((val, ctx) => {
   const trimmed = val.trim();
   if (!isAbsoluteHttpUrl(trimmed)) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: `Invalid URL: "${trimmed}" \u2014 must be an http(s) URL (e.g. https://idp.example.com)`
     });
   }
@@ -15234,7 +16623,7 @@ function refineCimdMetadataUrl(val, ctx, required) {
   if (trimmed === "") {
     if (required) {
       ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         message: "CIMD client metadata URL is required when CIMD is enabled"
       });
     }
@@ -15243,25 +16632,25 @@ function refineCimdMetadataUrl(val, ctx, required) {
   const error = getCimdClientMetadataUrlError(trimmed);
   if (error) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: error
     });
   }
 }
-var CimdConfigSchema = z4.object({
-  enabled: z4.boolean(),
-  clientMetadataUrl: z4.string()
+var CimdConfigSchema = z5.object({
+  enabled: z5.boolean(),
+  clientMetadataUrl: z5.string()
 }).superRefine((data, ctx) => {
   refineCimdMetadataUrl(data.clientMetadataUrl, ctx, data.enabled === true);
 });
-var EnterpriseManagedAuthIdpConfigSchema = z4.object({
+var EnterpriseManagedAuthIdpConfigSchema = z5.object({
   issuer: HttpUrlStringSchema,
-  clientId: z4.string().min(1),
-  clientSecret: z4.string().optional()
+  clientId: z5.string().min(1),
+  clientSecret: z5.string().optional()
 });
-var ClientConfigSchema = z4.object({
-  enterpriseManagedAuth: z4.object({
-    enabled: z4.boolean().optional(),
+var ClientConfigSchema = z5.object({
+  enterpriseManagedAuth: z5.object({
+    enabled: z5.boolean().optional(),
     idp: EnterpriseManagedAuthIdpConfigSchema
   }).optional(),
   cimd: CimdConfigSchema.optional()
@@ -16040,7 +17429,13 @@ async function parseArgs(argv) {
     "Tool argument as key=value pair",
     parseKeyValuePair2,
     {}
-  ).option("--uri <uri>", "URI of the resource (for resources/read method)").option(
+  ).option(
+    "--uri <uri>",
+    "URI of the resource (resources/read, resources/directory/read) or of the skill (skills/get)"
+  ).option(
+    "--cursor <cursor>",
+    "Opaque pagination cursor (for resources/directory/read; pass back the nextCursor from the previous page)."
+  ).option(
     "--prompt-name <promptName>",
     "Name of the prompt (for prompts/get method)"
   ).option(
@@ -16092,6 +17487,9 @@ async function parseArgs(argv) {
   ).option(
     "--strict",
     "Report tool-schema portability problems in full (path, issue, suggested fix) on stderr, and exit 6 if any is error-severity. Use with --method tools/list. Without it, a one-line count is printed instead."
+  ).option(
+    "--verify",
+    "Run the SEP-2640 conformance and digest checks over the skills returned, emit one JSON report per skill on stdout, and exit 7 if any fails or 8 if any could not be fully checked within the read bounds. Use with --method skills/list or --method skills/get."
   ).option(
     "--connect-timeout <ms>",
     `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc --server-url / target invocations; 0 = no timeout).`,
@@ -16195,6 +17593,13 @@ async function parseArgs(argv) {
       );
     }
   }
+  if (options.verify) {
+    if (options.method !== "skills/list" && options.method !== "skills/get") {
+      throw new Error(
+        "--verify requires --method skills/list or --method skills/get."
+      );
+    }
+  }
   const oauthStatePath = getStateFilePath();
   if (options.listStoredAuth) {
     const servers = await readOAuthServers(oauthStatePath);
@@ -16358,6 +17763,8 @@ async function parseArgs(argv) {
     toolMeta: options.toolMetadata,
     appInfo: options.appInfo === true,
     strict: options.strict === true,
+    verify: options.verify === true,
+    cursor: options.cursor,
     format: options.format
   };
   return {