@modelcontextprotocol/inspector 2.5.0 → 2.7.0

package/clients/cli/build/index.js

@@ -33,6 +33,7 @@ var INACTIVE_SUBSCRIPTION_STREAM_STATE = {
   honoredUris: []
 };
 var DEFAULT_TASK_TTL_MS = 6e4;
+var DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_FETCH_REQUESTS = 1e3;
 var DEFAULT_MODERN_LOG_LEVEL = "debug";
 function resolveModernLogLevel(settings) {
@@ -390,6 +391,656 @@ async function deleteStoreFile(filePath) {
   }
 }
 
+// ../../core/mcp/skillsSchemas.ts
+import { z } 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 = z.looseObject({
+  name: z.string().optional(),
+  description: z.string().optional()
+});
+var SkillResourceSchema = z.looseObject({
+  uri: z.string(),
+  digest: z.string().optional(),
+  size: z.number().optional()
+});
+var SkillEntrySchema = z.looseObject({
+  uri: z.string(),
+  frontmatter: SkillFrontmatterSchema,
+  resources: z.union([
+    z.literal(DYNAMIC_RESOURCES),
+    z.array(SkillResourceSchema)
+  ])
+});
+var ListSkillsResultSchema = z.looseObject({
+  skills: z.array(SkillEntrySchema),
+  nextCursor: z.string().optional()
+});
+var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
+  // 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: z.int().min(0),
+  cacheScope: z.enum(["public", "private"])
+});
+var GetSkillEnvelopeSchema = z.looseObject({
+  skill: SkillEntrySchema
+});
+var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
+  (result) => result.skill
+);
+var DirectoryChildSchema = ResourceSchema;
+var DirectoryReadResultSchema = z.looseObject({
+  resources: z.array(DirectoryChildSchema),
+  nextCursor: z.string().optional()
+});
+
+// ../../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;
+function isSkillCatalogLimit(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function resolveSkillCatalogBudget(settings) {
+  return {
+    maxSkills: isSkillCatalogLimit(settings?.skillCatalogMaxSkills) ? settings.skillCatalogMaxSkills : SKILL_MAX_CATALOG_SKILLS,
+    maxBytes: isSkillCatalogLimit(settings?.skillCatalogMaxBytes) ? settings.skillCatalogMaxBytes : SKILL_MAX_CATALOG_BYTES
+  };
+}
+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;
+  }
+  const pathlessRoot = parsed.pathname === "" && parsed.host !== "";
+  if (!pathlessRoot && !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/json/nullableUnion.ts
 var RENDERABLE_TYPES = [
   "string",
@@ -616,7 +1267,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
@@ -1176,16 +1831,19 @@ function oauthEndpointOverridesFromSettings(settings) {
   };
 }
 function storedFieldsToInspectorSettings(stored) {
-  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
+  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
   if (!hasAny) return void 0;
   const headersPairs = stored.headers ? Object.entries(stored.headers).map(([key, value]) => ({ key, value })) : [];
   const settings = {
     headers: headersPairs,
     env: envRecordToPairs(stored.env),
     metadata: normalizeStoredMetadata(stored.metadata),
-    connectionTimeout: stored.connectionTimeout ?? 0,
+    // Concrete product default, like taskTtl below: an absent field reads back
+    // as 30 s so the form shows the bound that will actually apply. An explicit
+    // 0 is preserved as-is — it is the user's opt-out, not a sentinel (#2320).
+    connectionTimeout: stored.connectionTimeout ?? DEFAULT_CONNECTION_TIMEOUT_MS,
     requestTimeout: stored.requestTimeout ?? 0,
-    // Unlike the timeouts (0 = "SDK default"), task TTL has a concrete product
+    // Unlike requestTimeout (0 = "SDK default"), task TTL has a concrete product
     // default so the form shows it and "Run as task" has a value to send.
     taskTtl: stored.taskTtl ?? DEFAULT_TASK_TTL_MS,
     autoRefreshOnListChanged: stored.autoRefreshOnListChanged ?? false,
@@ -1199,6 +1857,12 @@ function storedFieldsToInspectorSettings(stored) {
     // `[]`, which `inspectorSettingsToStoredFields` then omits on write.
     roots: stored.roots ?? []
   };
+  if (isSkillCatalogLimit(stored.skillCatalogMaxSkills)) {
+    settings.skillCatalogMaxSkills = stored.skillCatalogMaxSkills;
+  }
+  if (isSkillCatalogLimit(stored.skillCatalogMaxBytes)) {
+    settings.skillCatalogMaxBytes = stored.skillCatalogMaxBytes;
+  }
   if (isProtocolEra(stored.protocolEra)) {
     settings.protocolEra = stored.protocolEra;
   }
@@ -1252,6 +1916,8 @@ var INSPECTOR_FIELD_KEY_MAP = {
   paginatedLists: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
+  skillCatalogMaxSkills: true,
+  skillCatalogMaxBytes: true,
   oauth: true,
   roots: true
 };
@@ -1352,6 +2018,14 @@ function parseHeaderPair(value, previous = {}) {
   }
   return { ...previous, [key]: val };
 }
+function parseProtocolEra(value) {
+  if (!isProtocolEra(value)) {
+    throw new Error(
+      `Invalid protocol era: ${value}. Valid eras are: legacy, auto, modern`
+    );
+  }
+  return value;
+}
 var EMPTY_CATALOG_CONTENT = `${JSON.stringify({ mcpServers: {} }, null, 2)}
 `;
 function seedEmptyCatalog(resolvedPath) {
@@ -2753,10 +3427,16 @@ function headersToServerSettings(headers) {
     return void 0;
   }
   return {
-    headers: Object.entries(headers).map(([key, value]) => ({ key, value })),
+    ...defaultServerSettings(),
+    headers: Object.entries(headers).map(([key, value]) => ({ key, value }))
+  };
+}
+function defaultServerSettings() {
+  return {
+    headers: [],
     env: [],
     metadata: {},
-    connectionTimeout: 0,
+    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT_MS,
     requestTimeout: 0,
     taskTtl: DEFAULT_TASK_TTL_MS,
     maxFetchRequests: DEFAULT_MAX_FETCH_REQUESTS,
@@ -2765,11 +3445,19 @@ function headersToServerSettings(headers) {
     roots: []
   };
 }
-function mergeSettings(base, headers) {
-  const fromHeaders = headersToServerSettings(headers);
-  if (!fromHeaders) return base;
-  if (!base) return fromHeaders;
-  return { ...base, headers: fromHeaders.headers };
+function mergeSettings(base, overrides) {
+  let settings = base;
+  const fromHeaders = headersToServerSettings(overrides.headers);
+  if (fromHeaders) {
+    settings = settings ? { ...settings, headers: fromHeaders.headers } : fromHeaders;
+  }
+  if (overrides.protocolEra) {
+    settings = {
+      ...settings ?? defaultServerSettings(),
+      protocolEra: overrides.protocolEra
+    };
+  }
+  return settings;
 }
 async function loadServerEntries(serverOptions) {
   serverOptions = withDefaultCatalogPath(serverOptions);
@@ -2794,10 +3482,11 @@ async function loadServerEntries(serverOptions) {
           env: serverOptions.env,
           cwd: serverOptions.cwd
         }),
-        // Deliberate broadcast: a single `--header` set is merged into EVERY
-        // server in the catalog/config (fine for the common single-server case;
-        // for multi-server files, prefer per-server headers in the file itself).
-        settings: mergeSettings(entry.settings, serverOptions.headers)
+        // Deliberate broadcast: a single `--header` set (and `--protocol-era`)
+        // is merged into EVERY server in the catalog/config (fine for the
+        // common single-server case; for multi-server files, prefer per-server
+        // settings in the file itself).
+        settings: mergeSettings(entry.settings, serverOptions)
       };
     }
     return result;
@@ -2811,7 +3500,7 @@ async function loadServerEntries(serverOptions) {
   return {
     default: {
       config: configs[0],
-      settings: headersToServerSettings(serverOptions.headers)
+      settings: mergeSettings(void 0, serverOptions)
     }
   };
 }
@@ -2961,6 +3650,7 @@ function redactBody(body, contentType) {
   return body;
 }
 function findHeader(headers, name) {
+  if (!headers) return void 0;
   const target = name.toLowerCase();
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase() === target) return value;
@@ -2968,9 +3658,146 @@ function findHeader(headers, name) {
   return void 0;
 }
 function isLongLivedStreamResponse(method, contentType) {
-  if (method !== "GET") return false;
+  if (method.toUpperCase() !== "GET") return false;
   if (!contentType) return false;
-  return contentType.includes("text/event-stream") || contentType.includes("application/x-ndjson");
+  const type = contentType.toLowerCase();
+  return type.includes("text/event-stream") || type.includes("application/x-ndjson");
+}
+var CHALLENGE_BODY_MAX_BYTES = 64 * 1024;
+var CHALLENGE_BODY_READ_MS = 2e3;
+var TRUNCATED_BODY_SUFFIX = "\n[truncated]";
+var WITHHELD_TRUNCATED_JSON_BODY = "[truncated JSON body withheld: an incomplete body cannot be redacted]";
+function recordableChallengeBody(read, contentType) {
+  if (!read.truncated) return redactBody(read.text, contentType);
+  const looksLikeJson = (contentType ?? "").toLowerCase().includes("json") || /^\s*[{[]/.test(read.text);
+  if (looksLikeJson) return WITHHELD_TRUNCATED_JSON_BODY;
+  return redactBody(read.text, contentType) + TRUNCATED_BODY_SUFFIX;
+}
+async function readChallengeBody(response) {
+  let reader;
+  try {
+    const body = response.clone().body;
+    if (!body) return void 0;
+    reader = body.getReader();
+  } catch {
+    return void 0;
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  let timer;
+  const deadline = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7("timeout"), CHALLENGE_BODY_READ_MS);
+  });
+  try {
+    while (bytes < CHALLENGE_BODY_MAX_BYTES) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === "timeout") break;
+      if (next.done) return { text: text + decoder.decode(), truncated: false };
+      const chunk = next.value.subarray(0, CHALLENGE_BODY_MAX_BYTES - bytes);
+      bytes += chunk.byteLength;
+      text += decoder.decode(chunk, { stream: true });
+    }
+    reader.cancel().catch(() => {
+    });
+    return { text: text + decoder.decode(), truncated: true };
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var DEFAULT_STREAM_UPDATE_INTERVAL_MS = 250;
+function longLivedStreamFraming(contentType) {
+  return contentType?.toLowerCase().includes("application/x-ndjson") ? "ndjson" : "sse";
+}
+function watchLongLivedStream(response, id, framing, callbacks) {
+  const listener = callbacks.updateStream;
+  if (!listener) return;
+  const report = (state) => {
+    try {
+      listener(id, state);
+    } catch {
+    }
+  };
+  const intervalMs = callbacks.streamUpdateIntervalMs ?? DEFAULT_STREAM_UPDATE_INTERVAL_MS;
+  let body;
+  try {
+    body = response.clone().body;
+  } catch {
+    return;
+  }
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let eventCount = 0;
+  let pending = "";
+  let blockHasData = false;
+  let reportTimer = null;
+  const reportCount = () => {
+    if (intervalMs <= 0) {
+      report({ eventCount });
+      return;
+    }
+    if (reportTimer !== null) return;
+    reportTimer = setTimeout(() => {
+      reportTimer = null;
+      report({ eventCount });
+    }, intervalMs);
+  };
+  report({ eventCount });
+  const consumeLine = (line) => {
+    if (framing === "ndjson") {
+      if (line.trim() === "") return;
+      eventCount += 1;
+      reportCount();
+      return;
+    }
+    if (line === "") {
+      if (blockHasData) {
+        eventCount += 1;
+        blockHasData = false;
+        reportCount();
+      }
+      return;
+    }
+    if (line === "data" || line.startsWith("data:")) blockHasData = true;
+  };
+  const consumeCompleteLines = () => {
+    for (; ; ) {
+      const cr = pending.indexOf("\r");
+      const lf = pending.indexOf("\n");
+      const end = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
+      if (end === -1) return;
+      if (pending[end] === "\r") {
+        if (end === pending.length - 1) return;
+        const width = pending[end + 1] === "\n" ? 2 : 1;
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + width);
+      } else {
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + 1);
+      }
+    }
+  };
+  const pump = async () => {
+    try {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        pending += decoder.decode(value, { stream: true });
+        consumeCompleteLines();
+      }
+      if (pending.endsWith("\r")) consumeLine(pending.slice(0, -1));
+    } catch {
+    }
+    if (reportTimer !== null) {
+      clearTimeout(reportTimer);
+      reportTimer = null;
+    }
+    report({ eventCount, closedAt: /* @__PURE__ */ new Date() });
+  };
+  void pump();
 }
 function createFetchTracker(baseFetch, callbacks) {
   return async (input, init) => {
@@ -2978,7 +3805,7 @@ function createFetchTracker(baseFetch, callbacks) {
     const timestamp = /* @__PURE__ */ new Date();
     const id = `${timestamp.getTime()}-${Math.random().toString(36).slice(2, 11)}`;
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    const method = init?.method || "GET";
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
     const rawRequestHeaders = {};
     if (input instanceof Request) {
       input.headers.forEach((value, key) => {
@@ -3058,7 +3885,21 @@ function createFetchTracker(baseFetch, callbacks) {
       responseBody: void 0,
       duration
     };
+    if ((responseStatus === 401 || responseStatus === 403) && response.body && !response.bodyUsed) {
+      const read = await readChallengeBody(response);
+      entry.responseBody = read === void 0 ? void 0 : recordableChallengeBody(read, response.headers.get("content-type"));
+      callbacks.trackRequest?.(entry);
+      return response;
+    }
     callbacks.trackRequest?.(entry);
+    if (isLongLivedStream && response.body && !response.bodyUsed) {
+      watchLongLivedStream(
+        response,
+        id,
+        longLivedStreamFraming(response.headers.get("content-type")),
+        callbacks
+      );
+    }
     if (!isLongLivedStream && response.body && !response.bodyUsed) {
       const responseContentType = response.headers.get("content-type");
       try {
@@ -3380,7 +4221,7 @@ function createAuthChallengeInterceptFetch(baseFetch) {
     if (!challenge) {
       return response;
     }
-    await response.body?.cancel().catch(() => {
+    void response.body?.cancel().catch(() => {
     });
     throw new AuthChallengeError(
       challenge,
@@ -3528,14 +4369,24 @@ function createTransportNode(config, options = {}) {
     pipeStderr = false,
     onFetchRequest,
     onFetchResponseBody,
+    onFetchStreamUpdate,
     authProvider,
     settings,
     interceptAuthChallenges = false,
     onAuthChallengeObserved
   } = options;
+  const wantsFetchTracking = Boolean(
+    onFetchRequest || onFetchResponseBody || onFetchStreamUpdate
+  );
   const baseFetch = optionsFetchFn ?? createProxyFetch() ?? globalThis.fetch;
   const withChallengeObserver = (inner) => onAuthChallengeObserved ? createAuthChallengeObserverFetch(inner, onAuthChallengeObserved) : inner;
-  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(withChallengeObserver(baseFetch)) : withChallengeObserver(baseFetch);
+  const withTracking = (inner) => wantsFetchTracking ? createFetchTracker(inner, {
+    trackRequest: onFetchRequest,
+    updateResponseBody: onFetchResponseBody,
+    updateStream: onFetchStreamUpdate
+  }) : inner;
+  const trackedBase = withTracking(withChallengeObserver(baseFetch));
+  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(trackedBase) : trackedBase;
   if (serverType === "stdio") {
     const stdioConfig = config;
     const transport = new StdioClientTransport({
@@ -3561,11 +4412,7 @@ function createTransportNode(config, options = {}) {
     const sseConfig = config;
     const url = new URL(sseConfig.url);
     const configuredSseFetch = sseConfig.eventSourceInit?.fetch;
-    const sseFetch = configuredSseFetch ? withChallengeObserver(configuredSseFetch) : fetchWithOptionalAuthIntercept;
-    const trackedFetch = onFetchRequest ? createFetchTracker(sseFetch, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : sseFetch;
+    const trackedFetch = configuredSseFetch ? withTracking(withChallengeObserver(configuredSseFetch)) : fetchWithOptionalAuthIntercept;
     const headers = headersFromSettings(settings);
     const eventSourceInit = {
       ...sseConfig.eventSourceInit,
@@ -3576,15 +4423,11 @@ function createTransportNode(config, options = {}) {
       ...sseConfig.requestInit,
       ...headers && { headers }
     };
-    const postFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
     const transport = new SSEClientTransport(url, {
       authProvider,
       eventSourceInit,
       requestInit,
-      fetch: postFetch
+      fetch: fetchWithOptionalAuthIntercept
     });
     return { transport };
   } else {
@@ -3595,14 +4438,10 @@ function createTransportNode(config, options = {}) {
       ...httpConfig.requestInit,
       ...headers && { headers }
     };
-    const transportFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
     const transport = new StreamableHTTPClientTransport(url, {
       authProvider,
       requestInit,
-      fetch: transportFetch,
+      fetch: fetchWithOptionalAuthIntercept,
       // SEP-2350: how the transport reacts to a `403 insufficient_scope`
       // challenge. Defaults to the SDK's `reauthorize` when unset.
       ...settings?.oauthOnInsufficientScope && {
@@ -4238,6 +5077,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 +5125,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 +5316,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 +5332,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 +5385,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`
@@ -4576,7 +5419,7 @@ async function sendPlans(plans, budgetMs) {
 // ../../core/mcp/inspectorClient.ts
 import { Client } from "@modelcontextprotocol/client";
 import {
-  ProgressTokenSchema,
+  ProgressTokenSchema as ProgressTokenSchema2,
   RequestMetaSchema
 } from "@modelcontextprotocol/core";
 
@@ -4769,7 +5612,15 @@ var MessageTrackingTransport = class {
           "client"
         );
       } else if ("method" in message) {
-        this.callbacks.trackRequest?.(message, "client");
+        const request = message;
+        this.callbacks.trackRequest?.(request, "client");
+        const abortedBeforeSend = options?.requestSignal?.aborted === true;
+        return this.baseTransport.send(message, options).catch((err) => {
+          if (abortedBeforeSend || !options?.requestSignal?.aborted) {
+            this.callbacks.trackSendFailure?.(request, err);
+          }
+          throw err;
+        });
       }
     } else if ("method" in message) {
       this.callbacks.trackNotification?.(
@@ -4890,7 +5741,7 @@ import {
 } from "@modelcontextprotocol/client";
 
 // ../../core/mcp/modernTaskSchemas.ts
-import { z } from "zod/v4";
+import { z as z2 } from "zod/v4";
 var TASKS_EXTENSION_KEY = "io.modelcontextprotocol/tasks";
 var MODERN_PROTOCOL_VERSION2 = "2026-07-28";
 var TASKS_EXTENSION_CLIENT_CAPABILITY = {
@@ -4900,31 +5751,31 @@ var MODERN_TASK_HANDLE_META = "io.modelcontextprotocol/inspector/modernTaskHandl
 function isModernCreateTaskResult(result) {
   return typeof result === "object" && result !== null && result.resultType === "task" && typeof result.taskId === "string";
 }
-var ModernTaskStatusSchema = z.enum([
+var ModernTaskStatusSchema = z2.enum([
   "working",
   "input_required",
   "completed",
   "failed",
   "cancelled"
 ]);
-var ModernDetailedTaskSchema = z.looseObject({
-  taskId: z.string(),
+var ModernDetailedTaskSchema = z2.looseObject({
+  taskId: z2.string(),
   status: ModernTaskStatusSchema,
-  statusMessage: z.string().optional(),
-  createdAt: z.string(),
-  lastUpdatedAt: z.string(),
-  ttlMs: z.number().nullable().optional(),
-  pollIntervalMs: z.number().optional(),
+  statusMessage: z2.string().optional(),
+  createdAt: z2.string(),
+  lastUpdatedAt: z2.string(),
+  ttlMs: z2.number().nullable().optional(),
+  pollIntervalMs: z2.number().optional(),
   /** Present on `completed`: the original request's result (e.g. CallToolResult). */
-  result: z.record(z.string(), z.unknown()).optional(),
+  result: z2.record(z2.string(), z2.unknown()).optional(),
   /** Present on `failed`: the JSON-RPC error that ended the task. */
-  error: z.record(z.string(), z.unknown()).optional(),
+  error: z2.record(z2.string(), z2.unknown()).optional(),
   /** Present on `input_required`: embedded server→client requests, keyed by id. */
-  inputRequests: z.record(z.string(), z.unknown()).optional()
+  inputRequests: z2.record(z2.string(), z2.unknown()).optional()
 });
 var ModernGetTaskResultSchema = ModernDetailedTaskSchema;
-var ModernUpdateTaskResultSchema = z.looseObject({});
-var ModernCancelTaskResultSchema = z.looseObject({});
+var ModernUpdateTaskResultSchema = z2.looseObject({});
+var ModernCancelTaskResultSchema = z2.looseObject({});
 function normalizeModernTask(modern) {
   const { ttlMs, pollIntervalMs, ...rest } = modern;
   const normalized = { ...rest };
@@ -4937,9 +5788,10 @@ function readInputRequests(modern) {
 }
 
 // ../../core/mcp/extensions.ts
+import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/app-bridge";
 var EMA_EXTENSION_KEY = "io.modelcontextprotocol/enterprise-managed-authorization";
 var UI_EXTENSION_KEY = "io.modelcontextprotocol/ui";
-var MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+var MCP_APP_MIME_TYPE = RESOURCE_MIME_TYPE;
 var ADVERTISABLE_EXTENSIONS = [
   {
     key: TASKS_EXTENSION_KEY,
@@ -4958,6 +5810,18 @@ var ADVERTISABLE_EXTENSIONS = [
     // a conforming server checks the `mimeTypes` before serving a UI resource.
     defaultAdvertised: true,
     advertisement: { mimeTypes: [MCP_APP_MIME_TYPE] }
+  },
+  {
+    key: SKILLS_EXTENSION_KEY,
+    label: "Skills (io.modelcontextprotocol/skills)",
+    // The Skills extension (SEP-2640). SEP-2133 negotiates an extension from
+    // both sides, so a server may refuse `skills/list`, `skills/get` and
+    // `resources/directory/read` to a client that did not declare it — and the
+    // Inspector calls all three once the server declares its half. Advertised
+    // by default for that reason; turning it off is how to check a server's
+    // refusal path. Declared with no settings: SEP-2640 defines none for the
+    // client side. (#2373)
+    defaultAdvertised: true
   }
 ];
 function buildClientExtensions(input) {
@@ -5065,7 +5929,7 @@ import {
   ListResourcesResultSchema,
   ListResourceTemplatesResultSchema,
   ListPromptsResultSchema,
-  ResourceSchema,
+  ResourceSchema as ResourceSchema2,
   ResourceTemplateSchema,
   PromptSchema
 } from "@modelcontextprotocol/core";
@@ -5088,7 +5952,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 +5968,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 +6050,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 +6066,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
@@ -5845,42 +6709,191 @@ function withOAuthEndpointOverrides(fetchFn, getOverrides) {
   };
 }
 
-// ../../core/auth/oidcDiscoveryCompat.ts
-import {
-  OAuthMetadataSchema,
-  OpenIdProviderDiscoveryMetadataSchema
-} from "@modelcontextprotocol/core";
-var RFC8414_WELL_KNOWN = "/.well-known/oauth-authorization-server";
-var OIDC_WELL_KNOWN = "/.well-known/openid-configuration";
-var COMPAT_SOURCE_HEADER = "x-inspector-oauth-metadata-source";
-function oidcDiscoveryCandidates(rfc8414Url) {
-  let url;
+// ../../core/auth/requestTimeout.ts
+var DEFAULT_OAUTH_REQUEST_TIMEOUT_MS = 3e4;
+var OAuthRequestTimeoutError = class extends Error {
+  /**
+   * The endpoint that stalled, with sensitive query values redacted.
+   *
+   * Redacted in the constructor rather than at each display site, so every
+   * consumer is covered by construction: this error's message is recorded
+   * verbatim by `createFetchTracker` into the Network log and the persisted
+   * session, and an OAuth endpoint can carry a `code`, an `access_token` or a
+   * `client_secret` in its query string — which `fetchTracking` already
+   * deliberately redacts everywhere else it records a URL (Copilot). The path
+   * and every non-sensitive parameter survive, so the endpoint stays
+   * identifiable, which was the point of naming it.
+   */
+  url;
+  timeoutMs;
+  constructor(url, timeoutMs) {
+    const safeUrl = redactUrlQuery(url);
+    super(`OAuth request to ${safeUrl} timed out after ${timeoutMs}ms`);
+    this.name = "OAuthRequestTimeoutError";
+    this.url = safeUrl;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var MAX_TIMER_DELAY_MS = 2147483647;
+function normalizeBudget(timeoutMs) {
+  if (!Number.isFinite(timeoutMs)) return DEFAULT_OAUTH_REQUEST_TIMEOUT_MS;
+  return Math.min(MAX_TIMER_DELAY_MS, Math.max(0, Math.round(timeoutMs)));
+}
+function readNegotiatesEndpoint(hint) {
+  if (!hint) return true;
   try {
-    url = new URL(rfc8414Url);
+    return hint();
   } catch {
-    return [];
+    return true;
   }
-  if (!url.pathname.startsWith(RFC8414_WELL_KNOWN)) return [];
-  const path5 = url.pathname.slice(RFC8414_WELL_KNOWN.length);
-  if (path5 !== "" && !path5.startsWith("/")) return [];
-  if (path5 === "") return [new URL(OIDC_WELL_KNOWN, url.origin).href];
-  return [
-    new URL(`${OIDC_WELL_KNOWN}${path5}`, url.origin).href,
-    new URL(`${path5}${OIDC_WELL_KNOWN}`, url.origin).href
-  ];
 }
-function continuesDiscovery(status) {
-  return status >= 400 && status < 500 || status === 502;
-}
-async function releaseBody(response) {
-  await response.body?.cancel().catch(() => {
-  });
-}
-function isRfc8414OnlyMetadata(value) {
+var OAUTH_FORM_MEDIA_TYPE = "application/x-www-form-urlencoded";
+function exemptMcpEndpoint(getServerUrl, negotiatesEndpoint) {
+  return (url, headers) => {
+    if ((headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase() === OAUTH_FORM_MEDIA_TYPE) {
+      return false;
+    }
+    let serverUrl;
+    try {
+      serverUrl = getServerUrl();
+    } catch {
+      return true;
+    }
+    if (!serverUrl) return true;
+    const negotiated = readNegotiatesEndpoint(negotiatesEndpoint);
+    try {
+      const a = new URL(url);
+      const b = new URL(serverUrl);
+      if (a.origin !== b.origin) return false;
+      return negotiated || a.pathname === b.pathname;
+    } catch {
+      return true;
+    }
+  };
+}
+var REQUEST_DEADLINES = /* @__PURE__ */ new WeakMap();
+function requestHeadersOf(input, init) {
+  if (init?.headers) return new Headers(init.headers);
+  if (typeof input !== "string" && !(input instanceof URL)) {
+    return new Headers(input.headers);
+  }
+  return new Headers();
+}
+async function drainToEnd(reader) {
+  if (!reader) return;
+  for (; ; ) {
+    const { done } = await reader.read();
+    if (done) return;
+  }
+}
+function cancelBoth(reader, response) {
+  void reader?.cancel().catch(() => {
+  });
+  void response?.body?.cancel().catch(() => {
+  });
+}
+function requestUrlOf2(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function callerSignalOf(input, init) {
+  const explicit = init?.signal;
+  if (explicit !== void 0) return explicit ?? void 0;
+  if (typeof input !== "string" && !(input instanceof URL)) return input.signal;
+  return void 0;
+}
+function withOAuthRequestTimeout(fetchFn, timeoutMs = DEFAULT_OAUTH_REQUEST_TIMEOUT_MS, isExempt) {
+  const budget = normalizeBudget(timeoutMs);
+  return async (input, init) => {
+    const url = requestUrlOf2(input);
+    if (isExempt?.(url, requestHeadersOf(input, init))) {
+      return fetchFn(input, init);
+    }
+    const controller = new AbortController();
+    const callerSignal = callerSignalOf(input, init);
+    if (callerSignal?.aborted) throw callerSignal.reason;
+    const signal = callerSignal ? AbortSignal.any([controller.signal, callerSignal]) : controller.signal;
+    let timer;
+    let timedOut = false;
+    let onCallerAbort;
+    const abandoned = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new OAuthRequestTimeoutError(url, budget));
+        reject(new OAuthRequestTimeoutError(url, budget));
+      }, budget);
+      if (callerSignal) {
+        onCallerAbort = () => reject(callerSignal.reason);
+        callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    });
+    const nextInit = { ...init, signal };
+    REQUEST_DEADLINES.set(nextInit, budget);
+    let settled;
+    let drainReader;
+    try {
+      const response = await Promise.race([
+        fetchFn(input, nextInit),
+        abandoned
+      ]);
+      settled = response;
+      const copy = response.clone();
+      drainReader = copy.body?.getReader();
+      await Promise.race([drainToEnd(drainReader), abandoned]);
+      return response;
+    } catch (err) {
+      cancelBoth(drainReader, settled);
+      if (timedOut) throw new OAuthRequestTimeoutError(url, budget);
+      throw err;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      if (onCallerAbort && callerSignal) {
+        callerSignal.removeEventListener("abort", onCallerAbort);
+      }
+    }
+  };
+}
+
+// ../../core/auth/oidcDiscoveryCompat.ts
+import {
+  OAuthMetadataSchema,
+  OpenIdProviderDiscoveryMetadataSchema
+} from "@modelcontextprotocol/core";
+var RFC8414_WELL_KNOWN = "/.well-known/oauth-authorization-server";
+var OIDC_WELL_KNOWN = "/.well-known/openid-configuration";
+var COMPAT_SOURCE_HEADER = "x-inspector-oauth-metadata-source";
+function oidcDiscoveryCandidates(rfc8414Url) {
+  let url;
+  try {
+    url = new URL(rfc8414Url);
+  } catch {
+    return [];
+  }
+  if (!url.pathname.startsWith(RFC8414_WELL_KNOWN)) return [];
+  const path5 = url.pathname.slice(RFC8414_WELL_KNOWN.length);
+  if (path5 !== "" && !path5.startsWith("/")) return [];
+  if (path5 === "") return [new URL(OIDC_WELL_KNOWN, url.origin).href];
+  return [
+    new URL(`${OIDC_WELL_KNOWN}${path5}`, url.origin).href,
+    new URL(`${path5}${OIDC_WELL_KNOWN}`, url.origin).href
+  ];
+}
+function continuesDiscovery(status) {
+  return status >= 400 && status < 500 || status === 502;
+}
+async function releaseBody(response) {
+  await response.body?.cancel().catch(() => {
+  });
+}
+function releaseBodyDetached(response) {
+  void releaseBody(response);
+}
+function isRfc8414OnlyMetadata(value) {
   if (!OAuthMetadataSchema.safeParse(value).success) return false;
   return !OpenIdProviderDiscoveryMetadataSchema.safeParse(value).success;
 }
-function requestUrlOf2(input) {
+function requestUrlOf3(input) {
   if (typeof input === "string") return input;
   if (input instanceof URL) return input.href;
   return input.url;
@@ -5905,18 +6918,35 @@ function withRfc8414OidcCompat(fetchFn) {
     if (response.ok) return response;
     if (!continuesDiscovery(response.status)) return response;
     if (requestMethodOf(input, init) !== "GET") return response;
-    const candidates = oidcDiscoveryCandidates(requestUrlOf2(input));
+    const candidates = oidcDiscoveryCandidates(requestUrlOf3(input));
     if (candidates.length === 0) return response;
     const headers = discoveryHeaders(input, init);
+    const callerSignal = callerSignalOf(input, init);
     for (const candidate of candidates) {
+      if (callerSignal?.aborted) {
+        releaseBodyDetached(response);
+        throw callerSignal.reason;
+      }
       let probe;
       try {
-        probe = await fetchFn(candidate, { headers });
-      } catch {
+        probe = await fetchFn(candidate, { headers, signal: callerSignal });
+      } catch (err) {
+        if (err instanceof OAuthRequestTimeoutError) {
+          releaseBodyDetached(response);
+          throw err;
+        }
+        if (callerSignal?.aborted) {
+          releaseBodyDetached(response);
+          throw callerSignal.reason;
+        }
         return response;
       }
       if (!probe.ok) {
         await releaseBody(probe);
+        if (callerSignal?.aborted) {
+          releaseBodyDetached(response);
+          throw callerSignal.reason;
+        }
         if (continuesDiscovery(probe.status)) continue;
         return response;
       }
@@ -5926,6 +6956,10 @@ function withRfc8414OidcCompat(fetchFn) {
         body = await probe.text();
         parsed = JSON.parse(body);
       } catch {
+        if (callerSignal?.aborted) {
+          releaseBodyDetached(response);
+          throw callerSignal.reason;
+        }
         return response;
       }
       if (!isRfc8414OnlyMetadata(parsed)) {
@@ -5973,6 +7007,82 @@ function createSilentLogger() {
 }
 var silentLogger = createSilentLogger();
 
+// ../../core/mcp/inspectorClient.ts
+import { SdkError as SdkError5, SdkErrorCode as SdkErrorCode5 } from "@modelcontextprotocol/client";
+
+// ../../core/mcp/connectionDiagnostics.ts
+import { SdkError as SdkError3, SdkErrorCode as SdkErrorCode3 } from "@modelcontextprotocol/client";
+function isRequestTimeoutData(value) {
+  return typeof value === "object" && value !== null && typeof value.timeout === "number";
+}
+function isRequestTimeoutError(err) {
+  return SdkError3.isInstance(err) && err.code === SdkErrorCode3.RequestTimeout && isRequestTimeoutData(err.data);
+}
+function formatDuration(ms) {
+  const clamped = Math.max(0, ms);
+  if (clamped < 1e3) return `${Math.round(clamped)}ms`;
+  const totalSeconds = Math.round(clamped / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+var MAX_LISTED_OUTSTANDING_REQUESTS = 5;
+function describeStreamEndpoint(url) {
+  try {
+    return `GET ${new URL(url).pathname}`;
+  } catch {
+    return `GET ${url}`;
+  }
+}
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function describeOutstanding(requests, now) {
+  if (requests.length === 0) return "No requests are unanswered.";
+  const listed = requests.slice(0, MAX_LISTED_OUTSTANDING_REQUESTS).map((r) => `${r.method} (sent ${formatDuration(now - r.sentAt)} ago)`);
+  const rest = requests.length - listed.length;
+  const tail = rest > 0 ? `, and ${rest} more` : "";
+  const verb = requests.length === 1 ? "is" : "are";
+  return `${plural(requests.length, "request")} ${verb} unanswered: ${listed.join(", ")}${tail}.`;
+}
+function describeLastResponse(lastResponse, now) {
+  if (!lastResponse) return "No response has been received this session.";
+  return `Last response received ${formatDuration(now - lastResponse.receivedAt)} ago (${lastResponse.method}).`;
+}
+function describeStream(stream, now) {
+  if (!stream) return void 0;
+  const endpoint = describeStreamEndpoint(stream.url);
+  const events = plural(stream.eventCount, "event");
+  if (stream.closedAt !== void 0) {
+    return `Notification stream (${endpoint}) closed ${formatDuration(now - stream.closedAt)} ago after ${formatDuration(stream.closedAt - stream.openedAt)}, ${events} delivered.`;
+  }
+  return `Notification stream (${endpoint}) open for ${formatDuration(now - stream.openedAt)}, ${events} delivered.`;
+}
+function describeConnectionDiagnostics(diagnostics) {
+  const now = diagnostics.capturedAt;
+  const parts = [
+    describeOutstanding(diagnostics.outstandingRequests, now),
+    describeLastResponse(diagnostics.lastResponse, now),
+    describeStream(diagnostics.notificationStream, now)
+  ];
+  return parts.filter((p) => p !== void 0).join(" ");
+}
+function annotateRequestTimeout(err, method, diagnostics) {
+  if (!isRequestTimeoutError(err)) return err;
+  const data = {
+    ...err.data,
+    method,
+    diagnostics
+  };
+  const message = `Request timed out after ${formatDuration(err.data.timeout)} (${method}). ${describeConnectionDiagnostics(diagnostics)}`;
+  const annotated = new SdkError3(SdkErrorCode3.RequestTimeout, message, data);
+  annotated.cause = err;
+  return annotated;
+}
+
 // ../../core/auth/authorizationParams.ts
 var RESERVED_AUTHORIZATION_PARAMS = [
   "client_id",
@@ -6186,8 +7296,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 +7307,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 +8249,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 +8318,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 +8406,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";
@@ -7994,6 +9200,9 @@ var OAuthManager = class {
   }
 };
 
+// ../../core/mcp/remote/remoteClientTransport.ts
+import { SdkError as SdkError4, SdkErrorCode as SdkErrorCode4 } from "@modelcontextprotocol/client";
+
 // ../../core/mcp/remote/types.ts
 function oauthTokensToRemoteAuthState(tokens) {
   return {
@@ -8008,6 +9217,20 @@ function oauthTokensToRemoteAuthState(tokens) {
   };
 }
 
+// ../../core/mcp/remote/progressToken.ts
+import { ProgressTokenSchema } from "@modelcontextprotocol/core";
+function progressTokenOf(message) {
+  if ("method" in message && message.method === "notifications/progress" && "params" in message && typeof message.params === "object" && message.params !== null) {
+    const parsed = ProgressTokenSchema.safeParse(
+      message.params.progressToken
+    );
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  return void 0;
+}
+
 // ../../core/mcp/remote/remoteClientTransport.ts
 var DEFAULT_SSE_RESPONSE_TIMEOUT_MS = 6e4;
 function requestIdForMessage(message) {
@@ -8079,6 +9302,14 @@ var RemoteClientTransport = class {
   eventStreamConsumeTask = null;
   restartingEventStream = false;
   closed = false;
+  /**
+   * Long-lived streams the backend has reported open, by fetch entry id, with
+   * the last event count seen for each. `close()` reports them closed
+   * itself: it aborts the event channel before asking the backend to
+   * disconnect, so the backend watcher's own close report lands on an
+   * unconsumed queue and is lost with the session (#2318).
+   */
+  openStreams = /* @__PURE__ */ new Map();
   sseResponseWaits = /* @__PURE__ */ new Map();
   options;
   config;
@@ -8301,10 +9532,20 @@ var RemoteClientTransport = class {
           if (parsed.type === "message") {
             const msg = parsed.data;
             this.settleSseResponseWait(msg);
+            const progressToken = progressTokenOf(msg);
+            if (progressToken !== void 0) {
+              this.resetSseResponseWait(progressToken);
+            }
             this.onmessage?.(msg, void 0);
-          } else if (parsed.type === "fetch_request" && this.options.onFetchRequest) {
+          } else if (parsed.type === "fetch_request") {
             const entry = parsed.data;
-            this.options.onFetchRequest({
+            if (this.options.onFetchStreamUpdate && isLongLivedStreamResponse(
+              entry.method,
+              findHeader(entry.responseHeaders, "content-type")
+            )) {
+              this.openStreams.set(entry.id, 0);
+            }
+            this.options.onFetchRequest?.({
               ...entry,
               timestamp: typeof entry.timestamp === "string" ? new Date(entry.timestamp) : entry.timestamp
             });
@@ -8313,6 +9554,16 @@ var RemoteClientTransport = class {
               parsed.data.id,
               parsed.data.responseBody
             );
+          } else if (parsed.type === "fetch_stream_update" && this.options.onFetchStreamUpdate) {
+            const { id, eventCount, closedAt } = parsed.data;
+            if (closedAt !== void 0) this.openStreams.delete(id);
+            else if (this.openStreams.has(id)) {
+              this.openStreams.set(id, eventCount);
+            }
+            this.options.onFetchStreamUpdate(id, {
+              eventCount,
+              ...closedAt !== void 0 && { closedAt: new Date(closedAt) }
+            });
           } else if (parsed.type === "stdio_log" && this.options.onStderr) {
             this.options.onStderr({
               timestamp: new Date(parsed.data.timestamp),
@@ -8423,14 +9674,18 @@ var RemoteClientTransport = class {
   }
   waitForSseResponse(requestId) {
     return new Promise((resolve7, reject) => {
-      const timer = setTimeout(() => {
-        this.sseResponseWaits.delete(requestId);
-        reject(
-          new Error(
-            `Timed out waiting for MCP response on SSE (${this.sseResponseTimeoutMs}ms)`
-          )
-        );
-      }, this.sseResponseTimeoutMs);
+      let timer;
+      const arm = () => {
+        timer = setTimeout(() => {
+          this.sseResponseWaits.delete(requestId);
+          reject(
+            new SdkError4(SdkErrorCode4.RequestTimeout, "Request timed out", {
+              timeout: this.sseResponseTimeoutMs
+            })
+          );
+        }, this.sseResponseTimeoutMs);
+      };
+      arm();
       this.sseResponseWaits.set(requestId, {
         resolve: () => {
           clearTimeout(timer);
@@ -8439,10 +9694,21 @@ var RemoteClientTransport = class {
         reject: (error) => {
           clearTimeout(timer);
           reject(error);
+        },
+        // A progress notification for this request re-arms the full window so
+        // the browser-side deadline tracks the SDK client's progress-aware one
+        // rather than firing at a flat 60s (#2028).
+        resetTimeout: () => {
+          clearTimeout(timer);
+          arm();
         }
       });
     });
   }
+  /** Re-arm a pending request's SSE wait timeout on a matching progress note. */
+  resetSseResponseWait(requestId) {
+    this.sseResponseWaits.get(requestId)?.resetTimeout();
+  }
   async postSend(message, options, retryCount) {
     const requestId = requestIdForMessage(message);
     let sseWait;
@@ -8525,6 +9791,11 @@ var RemoteClientTransport = class {
     this.closed = true;
     this.cancelAllSseWaits(new Error("Transport closed"));
     await this.stopEventStream();
+    const closedAt = /* @__PURE__ */ new Date();
+    for (const [id, eventCount] of this.openStreams) {
+      this.options.onFetchStreamUpdate?.(id, { eventCount, closedAt });
+    }
+    this.openStreams.clear();
     if (this._sessionId) {
       try {
         await this.fetchFn(`${this.baseUrl}/api/mcp/disconnect`, {
@@ -8549,6 +9820,9 @@ var corePackageJson = {
   version: "0.0.0"
 };
 var MAX_URL_ELICITATION_RETRIES = 5;
+function connectionTimeoutMessage(timeoutMs) {
+  return `Connection timed out after ${timeoutMs} ms. To accommodate a slower server, you may increase the timeout value in Server Settings.`;
+}
 function createPendingAbortError() {
   return new Error("Pending request aborted");
 }
@@ -8560,20 +9834,13 @@ async function closeSubscriptionBestEffort(subscription) {
   } catch {
   }
 }
-function notificationMethodFromSchema(schema) {
-  if (schema !== null && typeof schema === "object") {
-    const literal = schema.shape?.method?.value;
-    if (typeof literal === "string") return literal;
-  }
-  return void 0;
-}
 function describeJsonType2(value) {
   if (value === null) return "null";
   if (Array.isArray(value)) return "array";
   return typeof value;
 }
 function isProgressToken(value) {
-  return ProgressTokenSchema.safeParse(value).success;
+  return ProgressTokenSchema2.safeParse(value).success;
 }
 function dropInvalidReservedMeta(meta, logger) {
   const result = RequestMetaSchema.safeParse(meta);
@@ -8603,19 +9870,28 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    */
   static MRTR_MAX_ROUNDS = 10;
   client = null;
-  appRendererClientProxy = null;
   // Lazily-built validator used only on the skipOutputValidation path to detect
   // (non-fatally) when a delivered result violates the tool's outputSchema.
   outputValidator = null;
   transport = null;
   baseTransport = null;
-  // Correlation for `markResponseRejected` (#1953): the method of each
-  // outbound request still awaiting a response, and — once one is answered —
-  // the id of the most recently answered request per method. Entries are
-  // dropped as responses arrive, so this holds at most one id per method
-  // rather than growing with the session.
-  outboundRequestMethods = /* @__PURE__ */ new Map();
+  // Every outbound request still awaiting a response, keyed by JSON-RPC id.
+  // Serves two readers: the `markResponseRejected` correlation (#1953), which
+  // needs the method, and the connection diagnostics (#2318), which need the
+  // method and when it went out. Entries are dropped as responses arrive; a
+  // request the SDK gave up on (a timeout, a cancel) stays until the session
+  // resets, because it is still unanswered and that is what the diagnostics
+  // report.
+  outstandingRequests = /* @__PURE__ */ new Map();
+  // The id of the most recently answered request per method, for
+  // `markResponseRejected` (#1953). At most one id per method, so it does not
+  // grow with the session.
   lastAnsweredRequestByMethod = /* @__PURE__ */ new Map();
+  // Connection diagnostics (#2318): the most recent response to one of our
+  // requests, and the most recent long-lived transport stream (the standalone
+  // `GET` on Streamable HTTP). Both per-session, reset with the maps above.
+  lastResponse;
+  notificationStream;
   /** True when the cached transport was built with an OAuth authProvider attached. */
   transportHasAuthProvider = false;
   /** Dedupes concurrent ambient auth challenges (reason + scopes). */
@@ -8883,12 +10159,27 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       resources: options.listChangedNotifications?.resources ?? true,
       prompts: options.listChangedNotifications?.prompts ?? true
     };
-    this.fetchFn = withOAuthEndpointOverrides(
+    const withOverrides = withOAuthEndpointOverrides(
       this.fetchFn ?? fetch,
       () => this.oauthManager?.getEndpointOverrides()
     );
-    this.fetchFn = withRfc8414OidcCompat(this.fetchFn);
-    this.effectiveAuthFetch = this.buildEffectiveAuthFetch();
+    this.fetchFn = withRfc8414OidcCompat(
+      withOAuthRequestTimeout(
+        withOverrides,
+        DEFAULT_OAUTH_REQUEST_TIMEOUT_MS,
+        exemptMcpEndpoint(
+          () => this.getServerUrl(),
+          // Legacy SSE negotiates its message endpoint inside the stream, so
+          // its path is unknowable here and the exemption has to widen to the
+          // origin. Streamable HTTP sends everything to the configured URL, so
+          // the path rule is exact there and same-origin OAuth stays bounded.
+          () => this.transportConfig?.type === "sse"
+        )
+      )
+    );
+    this.effectiveAuthFetch = this.buildEffectiveAuthFetch(
+      withRfc8414OidcCompat(withOAuthRequestTimeout(withOverrides))
+    );
     this.sessionId = options.sessionId;
     if (options.oauth || options.environment.oauth) {
       const oauthConfig = {
@@ -8996,7 +10287,6 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.tasksCapabilityAdvertised = capabilities.tasks !== void 0;
     this.urlElicitationCapabilityAdvertised = capabilities.elicitation?.url !== void 0;
     this.rootsListChangedCapabilityAdvertised = capabilities.roots?.listChanged === true;
-    this.appRendererClientProxy = null;
     this.clientInfo = options.clientIdentity ?? {
       name: corePackageJson.name.split("/")[1] ?? corePackageJson.name,
       version: corePackageJson.version
@@ -9005,9 +10295,60 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.clientInfo,
       Object.keys(clientOptions).length > 0 ? clientOptions : void 0
     );
+    this.annotateSdkRequestTimeouts(this.client);
   }
-  buildEffectiveAuthFetch() {
-    const base = this.fetchFn ?? fetch;
+  /**
+   * Decorate the SDK Client's `request` so a per-request timeout rejects with
+   * the connection's state at that moment instead of a bare `Request timed
+   * out` (#2318).
+   *
+   * `Protocol.request` is the one funnel every SDK verb goes through —
+   * `listTools`, `callTool`, `readResource`, the handshake's `initialize`,
+   * and this class's own raw `client.request` calls all reach the wire
+   * through it — so decorating it here covers the whole surface without a
+   * `catch` at each of the several dozen call sites, and covers the next
+   * verb added without anyone remembering to. The SDK offers no hook on the
+   * rejection path: the timeout error is constructed and thrown inside
+   * `request()` itself.
+   *
+   * Replaced on the instance rather than through a subclass because
+   * `request` is declared with two overloads (spec method with a keyed
+   * result, custom method with an explicit schema), and an `override` would
+   * have to restate both against types that move with every SDK release. One
+   * implementation signature serves both at runtime; the single cast on the
+   * way back is what the overloads cost.
+   */
+  annotateSdkRequestTimeouts(client) {
+    const sdkRequest = client.request.bind(client);
+    const decorated = async (...args) => {
+      try {
+        return await sdkRequest(...args);
+      } catch (err) {
+        throw annotateRequestTimeout(
+          err,
+          args[0].method,
+          this.getConnectionDiagnostics()
+        );
+      }
+    };
+    client.request = decorated;
+  }
+  /**
+   * @param base - the composed OAuth-path fetch, deadline innermost (#2319).
+   *
+   * Passed in rather than read off `this.fetchFn` because the two chains are
+   * bounded on different terms, not because one of them is unbounded. Both
+   * carry a deadline; the transport chain additionally exempts the MCP endpoint
+   * (`exemptMcpEndpoint`), since its bodies are streams meant to stay open and
+   * a long-running tool call may withhold its headers for minutes. Reusing it
+   * here would extend that exemption to the OAuth manager's own requests — and
+   * an authorization server published at the MCP endpoint's path would then go
+   * unbounded on the one chain that exists to bound it.
+   *
+   * The SDK's transport-internal discovery (the 401/refresh path) is covered by
+   * the transport chain's own deadline, not by this one.
+   */
+  buildEffectiveAuthFetch(base) {
     return createFetchTracker(base, {
       trackRequest: (entry) => this.dispatchFetchRequest({ ...entry, category: "auth" }),
       updateResponseBody: (id, body) => this.dispatchFetchRequestBodyUpdate(id, body)
@@ -9017,7 +10358,12 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     return {
       trackRequest: (message, origin) => {
         if (origin === "client") {
-          this.outboundRequestMethods.set(message.id, message.method);
+          this.outstandingRequests.set(message.id, {
+            id: message.id,
+            method: message.method,
+            sentAt: Date.now()
+          });
+          this.dispatchConnectionDiagnosticsChange();
         }
         const entry = {
           id: crypto.randomUUID(),
@@ -9028,14 +10374,22 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         };
         this.dispatchTypedEvent("message", entry);
       },
+      trackSendFailure: (message, error) => {
+        if (isRequestTimeoutError(error)) return;
+        if (this.outstandingRequests.delete(message.id)) {
+          this.dispatchConnectionDiagnosticsChange();
+        }
+      },
       trackResponse: (message, origin) => {
         const responseId = message.id;
         if (origin === "server" && responseId !== void 0) {
-          const method = this.outboundRequestMethods.get(responseId);
-          this.outboundRequestMethods.delete(responseId);
+          const method = this.outstandingRequests.get(responseId)?.method;
+          this.outstandingRequests.delete(responseId);
           if (method !== void 0) {
             this.lastAnsweredRequestByMethod.set(method, responseId);
+            this.lastResponse = { method, receivedAt: Date.now() };
           }
+          this.dispatchConnectionDiagnosticsChange();
         }
         const entry = {
           id: crypto.randomUUID(),
@@ -9642,8 +10996,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.clearReceiverTasks();
     this.resetSubscriptionStream();
     this.cancelledTaskIds.clear();
-    this.outboundRequestMethods.clear();
+    this.outstandingRequests.clear();
     this.lastAnsweredRequestByMethod.clear();
+    this.lastResponse = void 0;
+    this.notificationStream = void 0;
+    this.dispatchConnectionDiagnosticsChange();
     if (this.malformedListItems.size > 0) {
       this.malformedListItems.clear();
       this.dispatchTypedEvent("malformedListItemsChange", []);
@@ -9744,10 +11101,14 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         },
         onFetchRequest: (entry) => {
           this.dispatchFetchRequest({ ...entry, category: "transport" });
+          this.noteTransportStream(entry);
         },
         onFetchResponseBody: (id, body) => {
           this.dispatchFetchRequestBodyUpdate(id, body);
         },
+        onFetchStreamUpdate: (id, stream) => {
+          this.dispatchFetchRequestStreamUpdate(id, stream);
+        },
         ...this.serverSettings && { settings: this.serverSettings }
       };
       if (this.isHttpOAuthConfig() && oauthManager) {
@@ -9834,7 +11195,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.dispatchTypedEvent("statusChange", this.status);
       this.registerPeerRequestHandlers();
       this.registerPeerNotificationHandlers();
-      const connectTimeoutMs = this.serverSettings?.connectionTimeout ?? 0;
+      const connectTimeoutMs = this.serverSettings?.connectionTimeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+      let connectTimedOut = false;
       const connectPromise = this.client.connect(this.transport).catch((err) => {
         throw findNestedAuthError(err) ?? err;
       });
@@ -9854,14 +11216,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
           });
           let timer;
           const timeoutPromise = new Promise((_, reject) => {
-            timer = setTimeout(
-              () => reject(
-                new Error(
-                  `Connection timed out after ${connectTimeoutMs} ms`
-                )
-              ),
-              connectTimeoutMs
-            );
+            timer = setTimeout(() => {
+              connectTimedOut = true;
+              reject(new Error(connectionTimeoutMessage(connectTimeoutMs)));
+            }, connectTimeoutMs);
           });
           try {
             await Promise.race([connectPromise, timeoutPromise]);
@@ -9875,7 +11233,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       try {
         await this.invokeMcpClient(runConnect);
       } catch (err) {
-        if (connectTimeoutMs > 0) {
+        if (connectTimedOut) {
           await this.disconnect().catch(() => {
           });
         }
@@ -10024,7 +11382,6 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.activeToolCallAbortController?.abort("Disconnected");
     this.activeToolCallAbortController = void 0;
     this.clearReceiverTasks();
-    this.appRendererClientProxy = null;
     this.capabilities = void 0;
     this.serverInfo = void 0;
     this.instructions = void 0;
@@ -10049,31 +11406,19 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.dispatchTypedEvent("malformedListItemsChange", []);
   }
   /**
-   * Returns a client proxy for use by AppRenderer / @mcp-ui. Delegates to the
-   * internal MCP Client. Returns null when not connected. Use this instead of
-   * accessing the raw client so behavior can be adapted here later if needed.
+   * The SDK client for the MCP Apps host bridge, or null when not connected.
+   *
+   * ext-apps' `AppBridge` (2.0.0+, an SDK v2 peer) takes the v2 `Client`
+   * directly and registers its list-changed forwarding on it in the
+   * method-string form, so this hands out the real client. The Proxy that
+   * translated the 1.x peer's schema-first `setNotificationHandler(Schema,
+   * handler)` into that form is gone with it (#1745). Kept as the seam rather
+   * than exposing the field so the connected-status gate lives in one place
+   * and hooks, fakes and tests depend on the protocol, not the class.
    */
   getAppRendererClient() {
     if (!this.client || this.status !== "connected") return null;
-    if (this.appRendererClientProxy !== null)
-      return this.appRendererClientProxy;
-    const target = this.client;
-    this.appRendererClientProxy = new Proxy(this.client, {
-      get(proxyTarget, prop, receiver) {
-        const value = Reflect.get(proxyTarget, prop, receiver);
-        if (prop === "setNotificationHandler" && typeof value === "function") {
-          return (schemaOrMethod, ...rest) => {
-            const method = typeof schemaOrMethod === "string" ? schemaOrMethod : notificationMethodFromSchema(schemaOrMethod) ?? schemaOrMethod;
-            return value.apply(target, [
-              method,
-              ...rest
-            ]);
-          };
-        }
-        return value;
-      }
-    });
-    return this.appRendererClientProxy;
+    return this.client;
   }
   /**
    * Send a ping request to the server. Resolves when the server responds.
@@ -10235,7 +11580,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       const timer = setTimeout(() => {
         this.pendingRawWireRequests.delete(id);
         reject(
-          new Error(`Raw request "${method}" timed out after ${timeoutMs} ms`)
+          annotateRequestTimeout(
+            new SdkError5(SdkErrorCode5.RequestTimeout, "Request timed out", {
+              timeout: timeoutMs
+            }),
+            method,
+            this.getConnectionDiagnostics()
+          )
         );
       }, timeoutMs);
       this.pendingRawWireRequests.set(id, { resolve: resolve7, reject, timer });
@@ -10245,7 +11596,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
           clearTimeout(pending.timer);
           this.pendingRawWireRequests.delete(id);
         }
-        reject(err instanceof Error ? err : new Error(String(err)));
+        reject(
+          annotateRequestTimeout(
+            err instanceof Error ? err : new Error(String(err)),
+            method,
+            this.getConnectionDiagnostics()
+          )
+        );
       });
     });
     return resultSchema.parse(raw);
@@ -10418,7 +11775,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 +13375,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 +13406,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 +13508,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 +13564,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 +13606,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 SDK decoded it — the `{ skill }` envelope **and any
+   * other members the server sent**, such as the caching attributes. On a
+   * modern connection `resultType` is not among them: the codec checks it and
+   * removes it before the result gets here (#2373).
+   *
+   * 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 } : {}
+    };
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: SKILLS_GET_METHOD, params },
+          GetSkillEnvelopeSchema,
+          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 } : {}
+    };
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: RESOURCES_DIRECTORY_READ_METHOD, params },
+          DirectoryReadResultSchema,
+          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
@@ -12380,6 +13901,72 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   dispatchFetchRequestBodyUpdate(id, responseBody) {
     this.dispatchTypedEvent("fetchRequestBodyUpdate", { id, responseBody });
   }
+  dispatchFetchRequestStreamUpdate(id, stream) {
+    this.dispatchTypedEvent("fetchRequestStreamUpdate", { id, stream });
+    if (this.notificationStream?.id !== id) return;
+    this.notificationStream = {
+      ...this.notificationStream,
+      eventCount: stream.eventCount,
+      ...stream.closedAt && { closedAt: stream.closedAt.getTime() }
+    };
+    this.dispatchConnectionDiagnosticsChange();
+  }
+  /**
+   * Adopt a transport fetch as the notification stream when it is one — a
+   * `GET` answered with an unbounded event stream — so the diagnostics can
+   * say how long it has been open and what it has delivered (#2318). The
+   * newest such stream wins: the SDK reopens the standalone `GET` after a
+   * drop, and the current one is the one a stalled request is queued behind.
+   */
+  noteTransportStream(entry) {
+    if (!isLongLivedStreamResponse(
+      entry.method,
+      findHeader(entry.responseHeaders, "content-type")
+    )) {
+      return;
+    }
+    this.notificationStream = {
+      id: entry.id,
+      url: entry.url,
+      // The entry's `timestamp` is when the request went out; the stream is
+      // open from when the response headers arrived, `duration` later.
+      openedAt: entry.timestamp.getTime() + (entry.duration ?? 0),
+      eventCount: 0
+    };
+    this.dispatchConnectionDiagnosticsChange();
+  }
+  /**
+   * What this client is still waiting on, when it last heard back, and the
+   * state of the notification stream (#2318). A fresh snapshot per call —
+   * the same one `annotateRequestTimeout` writes a timeout message from, and
+   * the one `connectionDiagnosticsChange` carries.
+   */
+  getConnectionDiagnostics() {
+    return {
+      capturedAt: Date.now(),
+      // Copies, not the tracked records: the snapshot is handed to callers
+      // and carried on errors, and a mutation there must not reach the
+      // correlation state.
+      outstandingRequests: [...this.outstandingRequests.values()].map(
+        (request) => ({ ...request })
+      ),
+      ...this.lastResponse && { lastResponse: { ...this.lastResponse } },
+      ...this.notificationStream && {
+        notificationStream: this.publicStreamState(this.notificationStream)
+      }
+    };
+  }
+  /** The stream state minus the entry id, which is bookkeeping, not a fact. */
+  publicStreamState(stream) {
+    const { id: _id, ...state } = stream;
+    return state;
+  }
+  dispatchConnectionDiagnosticsChange() {
+    this.dispatchTypedEvent(
+      "connectionDiagnosticsChange",
+      this.getConnectionDiagnostics()
+    );
+  }
   /**
    * Get current session ID (from OAuth state authId)
    */
@@ -13259,7 +14846,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) {
@@ -13293,7 +14903,7 @@ function statusOf(error) {
   }
   return void 0;
 }
-var UNREACHABLE_PATTERN = /ENOTFOUND|ECONNREFUSED|ECONNRESET|EAI_AGAIN|ETIMEDOUT|fetch failed|getaddrinfo|connect timed out|aborted/i;
+var UNREACHABLE_PATTERN = /ENOTFOUND|ECONNREFUSED|ECONNRESET|EAI_AGAIN|ETIMEDOUT|fetch failed|getaddrinfo|connect(?:ion)? timed out|aborted/i;
 function classifyError(error, context) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
   const cause = causeOf(error);
@@ -13663,12 +15273,12 @@ function countFindings(results) {
   }
   return { errors, warnings };
 }
-function plural(count, noun) {
+function plural2(count, noun) {
   return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
 function summarizeFindings(results) {
   const { errors, warnings } = countFindings(results);
-  return `${plural(errors, "error")}, ${plural(warnings, "warning")} across ${plural(results.length, "tool")}`;
+  return `${plural2(errors, "error")}, ${plural2(warnings, "warning")} across ${plural2(results.length, "tool")}`;
 }
 function formatSchemaLintReport(results) {
   const lines = [];
@@ -13767,6 +15377,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 +15951,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 +15959,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,12 +16012,150 @@ 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) {
-  return getToolUiResourceUri(
-    tool
-  );
+  return getToolUiResourceUri(tool);
 }
 function readUiMeta(carrier) {
   const ui = carrier !== null && typeof carrier === "object" ? carrier._meta?.ui : void 0;
@@ -14463,13 +16220,245 @@ 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 = [];
+  const budget = resolveSkillCatalogBudget(client.getServerSettings?.());
+  let walkedSkills = 0;
+  let catalogBytes = 0;
+  for (const entry of entries) {
+    const withinBudget = walkedSkills < budget.maxSkills && catalogBytes < budget.maxBytes;
+    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 ${budget.maxSkills} skills / ${budget.maxBytes} bytes (raise it in the server's Skills settings). 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);
+        let charged = responseBytes(invocation.result);
+        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);
+            charged = Math.max(charged, entryBytes.byteLength);
+          } catch (err) {
+            fail(reasonOf(err));
+          }
+        }
+        receivedBytes += charged;
+        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 +16677,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 +16778,7 @@ async function runMethod(inspectorClient, args) {
     managedResourcesState?.destroy();
     managedResourceTemplatesState?.destroy();
     managedPromptsState?.destroy();
+    managedSkillsState?.destroy();
     managedTasksState?.destroy();
   }
 }
@@ -14736,7 +16793,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 +17244,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,17 +17261,21 @@ 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)`
     });
   }
 });
 var CIMD_METADATA_URL_INVALID_ERROR = "Must be a valid URL, like https://example.com/oauth/client.json";
-var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS";
+var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS, except on localhost, 127.0.0.1 or [::1]";
+var CIMD_HTTP_EXEMPT_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isCimdHttpExemptHost(hostname) {
+  return CIMD_HTTP_EXEMPT_HOSTS.has(hostname);
+}
 var CIMD_METADATA_URL_PATH_ERROR = "Must include a path (not the site root), like https://example.com/oauth/client.json";
 function getCimdClientMetadataUrlError(value) {
   const trimmed = value.trim();
@@ -15218,7 +17285,7 @@ function getCimdClientMetadataUrlError(value) {
   }
   try {
     const url = new URL(trimmed);
-    if (url.protocol !== "https:") {
+    if (url.protocol !== "https:" && !isCimdHttpExemptHost(url.hostname)) {
       return CIMD_METADATA_URL_HTTPS_ERROR;
     }
     if (url.pathname === "/" || url.pathname === "") {
@@ -15234,7 +17301,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 +17310,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()
@@ -15865,7 +17932,9 @@ function findStoredToken(servers, serverUrl) {
 }
 async function refreshStoredAuthToken(serverUrl, statePath, deps = {}) {
   const refresh = deps.refresh ?? refreshAuthorization;
-  const storedAuthFetch = withRfc8414OidcCompat(createProxyFetch() ?? fetch);
+  const storedAuthFetch = withRfc8414OidcCompat(
+    withOAuthRequestTimeout(createProxyFetch() ?? fetch)
+  );
   const discover = deps.discover ?? ((authorizationServerUrl, options) => discoverAuthorizationServerMetadata4(authorizationServerUrl, {
     ...options,
     // A caller-supplied fetch is left alone — it is theirs to compose. The
@@ -16040,7 +18109,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 +18167,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).`,
@@ -16102,6 +18180,10 @@ async function parseArgs(argv) {
       }
       return n;
     }
+  ).option(
+    "--protocol-era <era>",
+    "Protocol era to negotiate: legacy, auto, or modern. Overrides the file-level protocolEra for --catalog/--config runs; ad-hoc --server-url / target runs otherwise default to legacy.",
+    parseProtocolEra
   ).option(
     "--format <format>",
     "Output format: text (default; pretty-printed) or json (one JSON object on stdout, no banners).",
@@ -16195,6 +18277,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);
@@ -16240,7 +18329,10 @@ async function parseArgs(argv) {
     env: options.e,
     // `--header` is merged into the resolved server's settings (overriding any
     // file-level headers); file timeouts/OAuth are preserved. See #1482.
-    headers: options.header
+    headers: options.header,
+    // `--protocol-era` feeds `settings.protocolEra` the same way, so an ad-hoc
+    // launch can pick a non-legacy era without an mcp.json entry (#2208).
+    protocolEra: options.protocolEra
   };
   if (options.method === "servers/list") {
     const servers = await listServerEntries(serverOptions);
@@ -16358,6 +18450,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 {