npm - @qwen-code/qwen-code - Versions diffs - 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784 - Mend

@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (464) hide show

package/chunks/{chunk-E4UEO3XM.js → chunk-ME4JBHSB.js} RENAMED Viewed

@@ -449,6 +449,23 @@ var MAX_PERSISTED_MIME_CHARS = 120;
 var MAX_PERSISTED_FIELD_CHARS = 200;
 var MAX_PERSISTED_TIMESTAMP_CHARS = 64;
 var SECRET_TOKEN_VALUE_PATTERN = /(?:^|\s)(?:bearer\s+\S{8,}|sk-[A-Za-z0-9_-]{12,}|(?:gh[pousr]|github_pat)_[A-Za-z0-9_/-]{12,}|[a-f0-9]{40,}|[A-Za-z0-9+/]{48,}={0,2})(?:$|\s)/i;
+function getWebPreviewSnapshotId(artifact) {
+  const id = /^preview-([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/.exec(
+    artifact.managedId ?? ""
+  )?.[1];
+  const sha256 = artifact.metadata?.[PUBLISHED_CONTENT_SHA256_METADATA_KEY];
+  if (!id || artifact.kind !== "html" || artifact.storage !== "published" || artifact.metadata?.["artifactType"] !== "web_preview_snapshot" || typeof sha256 !== "string" || !/^[0-9a-f]{64}$/.test(sha256) || artifact.source !== void 0 && (artifact.source !== "tool" || artifact.toolName?.toLowerCase() !== "artifact") || artifact.toolName !== void 0 && artifact.toolName.toLowerCase() !== "artifact")
+    return void 0;
+  try {
+    const url = new URL(artifact.url ?? "");
+    if (url.protocol === "file:" && !url.host && !url.search && !url.hash && url.pathname.endsWith(`/artifacts/snapshots/${id}/index.html`))
+      return id;
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+__name(getWebPreviewSnapshotId, "getWebPreviewSnapshotId");
 function isSessionArtifactRecord(record) {
   return isTranscriptArtifactRecord(record);
 }
@@ -797,7 +814,7 @@ function isForkSafeArtifact(artifact) {
   if (artifact.metadata && hasRestoreUnsafeMetadata(artifact.metadata)) {
     return false;
   }
-  if (artifact.url && hasRestoreUnsafeUrl(artifact.url)) {
+  if (artifact.url && hasRestoreUnsafeUrl(artifact.url) && !getWebPreviewSnapshotId(artifact)) {
     return false;
   }
   return true;
@@ -1233,6 +1250,296 @@ function getNonNegativeInteger(record, key) {
 }
 __name(getNonNegativeInteger, "getNonNegativeInteger");
+// packages/core/src/tools/artifact/html.ts
+init_esbuild_shims();
+var MAX_ARTIFACT_BYTES = 16 * 1024 * 1024;
+var CSS_RESET = `*,*::before,*::after{box-sizing:border-box}
+html{-webkit-text-size-adjust:100%}
+body{margin:0;padding:1.5rem;font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;line-height:1.5;color:#1a1a1a;background:#fff}
+img,svg,video,canvas{max-width:100%;height:auto}
+pre,table{max-width:100%;overflow-x:auto}
+:where(a){color:#0969da}`;
+var DEFAULT_TITLE = "Artifact";
+function sanitizeArtifactTitle(raw) {
+  const cleaned = (raw ?? "").replace(/\s+/g, " ").trim().slice(0, 120);
+  return cleaned || DEFAULT_TITLE;
+}
+__name(sanitizeArtifactTitle, "sanitizeArtifactTitle");
+function escapeForTitle(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeForTitle, "escapeForTitle");
+function validateSelfContained(fragment) {
+  if (!fragment.trim()) {
+    return "Artifact file is empty \u2014 write the page content (a body-only HTML fragment) first.";
+  }
+  const scan = normalizeAttributeQuotes(fragment);
+  const head = fragment.replace(/^\s+/, "").replace(/^(?:<!--[\s\S]*?-->\s*)+/, "");
+  const wrapperTag = /^(?:<!doctype\b|<html[\s>]|<head[\s>]|<body[\s>])/i.exec(
+    head
+  );
+  if (wrapperTag) {
+    return `Write a body-only fragment \u2014 it starts with a full-document tag (${wrapperTag[0].trim()}). Omit <!doctype>, <html>, <head>, and <body>; they are added at publish time.`;
+  }
+  const extResource = /\b(?:src|srcset|poster)\s*=\s*["']?\s*(?:https?:)?\/\//i.exec(scan) ?? /<link\b[^>]*\bhref\s*=\s*["']?\s*(?:https?:)?\/\//i.exec(scan);
+  if (extResource) {
+    return `Artifact must be self-contained \u2014 found an external reference (${truncate(extResource[0])}). Inline scripts/styles and embed assets as data: URIs.`;
+  }
+  const jsUri = /\b(?:href|src)\s*=\s*["']?\s*javascript\s*:/i.exec(scan);
+  if (jsUri) {
+    return `Artifact must be self-contained \u2014 found a javascript: URI (${truncate(jsUri[0])}). Use inline <script> blocks instead.`;
+  }
+  const extScript = /\b(?:fetch|WebSocket|XMLHttpRequest)\s*\(\s*["']\s*(?:https?|wss?):\/\//i.exec(
+    scan
+  ) ?? /\bimport\s*\(\s*["'](?:https?:)?\/\//i.exec(scan) ?? /\bwindow\.open\s*\(/i.exec(scan) ?? /\blocation\.\w+\s*[=(]/i.exec(scan) ?? /\bnavigator\.sendBeacon\s*\(\s*["']\s*(?:https?:)?\/\//i.exec(scan);
+  if (extScript) {
+    return `Artifact must be self-contained \u2014 found browser network egress (${truncate(extScript[0])}). Embed data in the artifact instead of fetching it at runtime.`;
+  }
+  const metaRefresh = /<meta\b[^>]*http-equiv\s*=\s*["']?refresh["']?[^>]*\burl\s*=\s*(?:https?:)?\/\//i.exec(
+    scan
+  );
+  if (metaRefresh) {
+    return `Artifact must be self-contained \u2014 found a meta refresh redirect (${truncate(metaRefresh[0])}).`;
+  }
+  const extCss = /(?:@import\s+(?:url\()?|url\()\s*["']?\s*(?:https?:)?\/\//i.exec(scan);
+  if (extCss) {
+    return `Artifact must be self-contained \u2014 found an external CSS reference (${truncate(extCss[0])}). Inline CSS and embed fonts/images as data: URIs.`;
+  }
+  return null;
+}
+__name(validateSelfContained, "validateSelfContained");
+function normalizeAttributeQuotes(s) {
+  return s.replace(/&quot;|&#34;|&#x22;/gi, '"').replace(/&apos;|&#39;|&#x27;/gi, "'");
+}
+__name(normalizeAttributeQuotes, "normalizeAttributeQuotes");
+function truncate(s, max = 60) {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max)}\u2026` : t;
+}
+__name(truncate, "truncate");
+function wrapArtifactHtml(bodyFragment, title) {
+  const safeTitle = escapeForTitle(sanitizeArtifactTitle(title));
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; font-src data:; media-src data:; connect-src 'none'; form-action 'none'; base-uri 'none'; frame-ancestors 'none'; sandbox allow-scripts;">
+<title>${safeTitle}</title>
+<style>${CSS_RESET}</style>
+</head>
+<body>
+${bodyFragment}
+</body>
+</html>
+`;
+}
+__name(wrapArtifactHtml, "wrapArtifactHtml");
+function byteLength(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+__name(byteLength, "byteLength");
+// packages/core/src/tools/artifact/artifact-snapshots.ts
+init_esbuild_shims();
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { constants, promises as fs } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var SNAPSHOT_REFERENCES_METADATA_KEY = "qwen.snapshot.references";
+async function saveArtifactSnapshot(html, title, publishedUrl, sessionId, runtimeBaseDir) {
+  const id = randomUUID();
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  await fs.mkdir(root, { recursive: true });
+  const dir = path.join(root, id);
+  await fs.mkdir(dir);
+  const file = path.join(dir, "index.html");
+  try {
+    const references = path.join(dir, "references");
+    await fs.mkdir(references);
+    await fs.writeFile(
+      path.join(references, snapshotReference(sessionId)),
+      "",
+      {
+        flag: "wx",
+        mode: 384,
+        flush: true
+      }
+    );
+    await fs.writeFile(file, html, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384,
+      flush: true
+    });
+    await syncSnapshotDirectory(references);
+    await syncSnapshotDirectory(dir);
+    await syncSnapshotDirectory(root);
+  } catch (error) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  return {
+    kind: "html",
+    storage: "published",
+    title,
+    url: pathToFileURL(file).href,
+    managedId: `preview-${id}`,
+    mimeType: "text/html",
+    sizeBytes: Buffer.byteLength(html, "utf8"),
+    metadata: {
+      artifactType: "web_preview_snapshot",
+      [SNAPSHOT_REFERENCES_METADATA_KEY]: 1,
+      publishedUrl,
+      [PUBLISHED_CONTENT_SHA256_METADATA_KEY]: createHash2("sha256").update(html).digest("hex")
+    }
+  };
+}
+__name(saveArtifactSnapshot, "saveArtifactSnapshot");
+async function readArtifactSnapshot(artifact, runtimeBaseDir) {
+  const id = getWebPreviewSnapshotId(artifact);
+  const sha256 = artifact.metadata?.[PUBLISHED_CONTENT_SHA256_METADATA_KEY];
+  const unavailable = /* @__PURE__ */ __name(() => new Error("Saved webpage version is unavailable."), "unavailable");
+  if (!id) throw unavailable();
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  const file = path.join(root, id, "index.html");
+  if (artifact.url !== pathToFileURL(file).href) throw unavailable();
+  const realRoot = await fs.realpath(root);
+  if (await fs.realpath(file) !== path.join(realRoot, id, "index.html")) {
+    throw unavailable();
+  }
+  const handle = await fs.open(
+    file,
+    // O_NOFOLLOW refuses a symlink swapped in after the realpath check, and
+    // O_NONBLOCK keeps a FIFO swapped into the same window from blocking the
+    // open: the path is only proven to be a regular file by the fstat below.
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > MAX_ARTIFACT_BYTES) throw unavailable();
+    const bytes = Buffer.alloc(stat.size + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const { bytesRead } = await handle.read(
+        bytes,
+        length,
+        bytes.length - length
+      );
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    const content = bytes.subarray(0, length);
+    if (length !== stat.size || createHash2("sha256").update(content).digest("hex") !== sha256) {
+      throw unavailable();
+    }
+    return content.toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+__name(readArtifactSnapshot, "readArtifactSnapshot");
+function snapshotReference(sessionId, operationId) {
+  const owner = createHash2("sha256").update(sessionId).digest("hex");
+  return operationId ? `${owner}-${createHash2("sha256").update(operationId).digest("hex")}` : owner;
+}
+__name(snapshotReference, "snapshotReference");
+async function syncSnapshotDirectory(directory) {
+  try {
+    const handle = await fs.open(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (process.platform !== "win32") throw error;
+  }
+}
+__name(syncSnapshotDirectory, "syncSnapshotDirectory");
+async function snapshotDirectory(artifact, runtimeBaseDir) {
+  const id = getWebPreviewSnapshotId(artifact);
+  if (!id) return void 0;
+  const root = path.join(runtimeBaseDir, "artifacts", "snapshots");
+  const dir = path.join(root, id);
+  if (artifact.url !== pathToFileURL(path.join(dir, "index.html")).href) {
+    return void 0;
+  }
+  if (artifact.metadata?.[SNAPSHOT_REFERENCES_METADATA_KEY] !== 1)
+    return void 0;
+  const realRoot = await fs.realpath(root);
+  if (await fs.realpath(dir) !== path.join(realRoot, id)) return void 0;
+  if (await fs.realpath(path.join(dir, "index.html")) !== path.join(realRoot, id, "index.html"))
+    return void 0;
+  if (await fs.realpath(path.join(dir, "references")) !== path.join(realRoot, id, "references")) {
+    return void 0;
+  }
+  return dir;
+}
+__name(snapshotDirectory, "snapshotDirectory");
+async function retainArtifactSnapshot(artifact, runtimeBaseDir, sessionId, operationId) {
+  try {
+    const dir = await snapshotDirectory(artifact, runtimeBaseDir);
+    if (!dir) return;
+    const references = path.join(dir, "references");
+    const owner = snapshotReference(sessionId);
+    const entries = await fs.readdir(references);
+    if (!operationId && entries.some((entry) => entry === owner || entry.startsWith(`${owner}-`)))
+      return;
+    await fs.writeFile(
+      path.join(references, snapshotReference(sessionId, operationId)),
+      "",
+      { flag: "wx", mode: 384, flush: true }
+    );
+    await syncSnapshotDirectory(references);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST" && !(code === "ENOENT" && !operationId)) throw error;
+  }
+}
+__name(retainArtifactSnapshot, "retainArtifactSnapshot");
+async function deleteArtifactSnapshot(artifact, runtimeBaseDir, sessionId, operationId, assertCleanupOwned) {
+  try {
+    const dir = await snapshotDirectory(artifact, runtimeBaseDir);
+    if (!dir) return;
+    await releaseSnapshotDirectory(
+      dir,
+      sessionId,
+      operationId,
+      assertCleanupOwned
+    );
+  } catch {
+    assertCleanupOwned?.();
+  }
+}
+__name(deleteArtifactSnapshot, "deleteArtifactSnapshot");
+async function releaseSnapshotDirectory(dir, sessionId, operationId, assertCleanupOwned) {
+  const references = path.join(dir, "references");
+  const owner = snapshotReference(sessionId, operationId);
+  let released = false;
+  for (const reference of await fs.readdir(references)) {
+    if (reference === owner || !operationId && reference.startsWith(`${owner}-`)) {
+      assertCleanupOwned?.();
+      await fs.unlink(path.join(references, reference));
+      released = true;
+    }
+  }
+  if (!released) return;
+  try {
+    assertCleanupOwned?.();
+    await fs.rmdir(references);
+  } catch (error) {
+    if (error.code === "ENOTEMPTY") return;
+    throw error;
+  }
+  const file = path.join(dir, "index.html");
+  assertCleanupOwned?.();
+  await fs.unlink(file);
+  assertCleanupOwned?.();
+  await fs.rmdir(dir);
+}
+__name(releaseSnapshotDirectory, "releaseSnapshotDirectory");
 export {
   TranscriptRecordPreparationError,
   stripGeneratedAttachmentTokens,
@@ -1250,6 +1557,7 @@ export {
   WORKSPACE_CONTENT_MTIME_MS_METADATA_KEY,
   WORKSPACE_CONTENT_SIZE_BYTES_METADATA_KEY,
   PUBLISHED_CONTENT_SHA256_METADATA_KEY,
+  getWebPreviewSnapshotId,
   isSessionArtifactRecord,
   selectActiveSideArtifactRecordUuids,
   stableSessionArtifactId,
@@ -1261,7 +1569,16 @@ export {
   isPrototypeMetadataKey,
   isReservedWorkspaceMetadataKey,
   isAdoptableContentFingerprintKey,
-  metadataBudgetBytes
+  metadataBudgetBytes,
+  MAX_ARTIFACT_BYTES,
+  sanitizeArtifactTitle,
+  validateSelfContained,
+  wrapArtifactHtml,
+  byteLength,
+  saveArtifactSnapshot,
+  readArtifactSnapshot,
+  retainArtifactSnapshot,
+  deleteArtifactSnapshot
 };
 /**
  * @license
@@ -1273,3 +1590,8 @@ export {
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BV6Q5HMY.js → chunk-MJHLKWGJ.js} RENAMED Viewed

@@ -2,17 +2,18 @@
 "use strict";
 import {
   ACP_ROUTE_ID_PREFIX
-} from "./chunk-MF6E7FSA.js";
+} from "./chunk-INGBUYL6.js";
 import {
   isOpenRouterHostname
-} from "./chunk-CXTPVBFA.js";
+} from "./chunk-GSS4SZNG.js";
 import {
   REASONING_EFFORT_TIERS,
   clampReasoningEffort,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
-  parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+  parseModelReasoningCapabilities,
+  reasoningEffortsForCapability
+} from "./chunk-ARDHE6MM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -185,9 +186,9 @@ function getConfiguredModelReasoning(config, modelId = config.getModel?.(), fall
 __name(getConfiguredModelReasoning, "getConfiguredModelReasoning");
 function getReasoningEffortsForConfig(config) {
   const modelId = config.getModel?.();
-  const reasoning = getConfiguredModelReasoning(config, modelId, false);
-  if (reasoning) return reasoning.toggleOnly ? [] : reasoning.efforts;
-  return REASONING_EFFORT_TIERS;
+  return reasoningEffortsForCapability(
+    getConfiguredModelReasoning(config, modelId, false)
+  );
 }
 __name(getReasoningEffortsForConfig, "getReasoningEffortsForConfig");
 function parseReasoningSelection(value) {

package/chunks/{chunk-NFYEQRLG.js → chunk-MQRLLBMQ.js} RENAMED Viewed

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-YBUMTY7B.js";
+} from "./chunk-66N6C4EH.js";
 import {
   loadUndici
 } from "./chunk-EWJTAP3Y.js";

package/chunks/{chunk-O4KNCAX4.js → chunk-NCPFOLM2.js} RENAMED Viewed

@@ -19583,8 +19583,19 @@ var findRootNode = /* @__PURE__ */ __name((node) => {
 var useBoxMetrics = /* @__PURE__ */ __name((ref) => {
   const [metrics, setMetrics] = (0, import_react33.useState)(emptyMetrics);
   const [hasMeasured, setHasMeasured] = (0, import_react33.useState)(false);
+  const guardRef = (0, import_react33.useRef)({ count: 0, windowStart: 0 });
   const { stdout } = use_stdout_default();
   const updateMetrics = (0, import_react33.useCallback)(() => {
+    const guard = guardRef.current;
+    const now = performance.now();
+    if (now - guard.windowStart >= 16) {
+      guard.count = 0;
+      guard.windowStart = now;
+    }
+    if (guard.count >= 32) {
+      return;
+    }
+    guard.count += 1;
     const layout = ref.current?.yogaNode?.getComputedLayout() ?? emptyMetrics;
     setMetrics((previousMetrics) => {
       const hasChanged = previousMetrics.width !== layout.width || previousMetrics.height !== layout.height || previousMetrics.left !== layout.left || previousMetrics.top !== layout.top;

package/chunks/{chunk-2SZH22YO.js → chunk-NJ2OFVUX.js} RENAMED Viewed

@@ -16,7 +16,7 @@ import {
   getMeter,
   isTelemetrySdkInitialized,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   FatalConfigError,
   QWEN_DIR,
@@ -8489,6 +8489,117 @@ async function resolveTelemetrySettings(options) {
 }
 __name(resolveTelemetrySettings, "resolveTelemetrySettings");
+// packages/core/src/skills/types.ts
+init_esbuild_shims();
+function parseModelField(frontmatter) {
+  const raw = frontmatter["model"];
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new Error('"model" must be a string');
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "" || trimmed === "inherit") {
+    return void 0;
+  }
+  return trimmed;
+}
+__name(parseModelField, "parseModelField");
+function parseUserInvocableField(frontmatter) {
+  const raw = frontmatter["user-invocable"];
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === true || raw === "true") {
+    return true;
+  }
+  if (raw === false || raw === "false") {
+    return false;
+  }
+  return void 0;
+}
+__name(parseUserInvocableField, "parseUserInvocableField");
+function parsePathsField(frontmatter) {
+  const raw = frontmatter["paths"];
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error('"paths" must be an array of glob patterns');
+  }
+  const cleaned = raw.map((p) => String(p).trim()).filter((p) => p.length > 0);
+  for (const pattern of cleaned) {
+    const normalized = pattern.replace(/\\/g, "/");
+    if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
+      throw new Error(
+        `"paths" entry "${pattern}" looks absolute; patterns are project-root-relative \u2014 drop the leading slash / drive letter`
+      );
+    }
+    const segments = normalized.split("/");
+    if (segments.some((seg) => seg === "..")) {
+      throw new Error(
+        `"paths" entry "${pattern}" contains a ".." segment that escapes the project root; patterns must stay within the project`
+      );
+    }
+  }
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+__name(parsePathsField, "parsePathsField");
+var SKILL_NAME_PATTERN = /^[\p{L}\p{N}_:.-]+$/u;
+function parseAllowedToolsField(frontmatter) {
+  const raw = frontmatter["allowedTools"];
+  if (raw == null) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error('"allowedTools" must be an array');
+  }
+  return raw.map(String);
+}
+__name(parseAllowedToolsField, "parseAllowedToolsField");
+function validateSkillName(name) {
+  if (!SKILL_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `"name" must match ${SKILL_NAME_PATTERN} (letters, digits, _, :, ., -); got "${name}"`
+    );
+  }
+}
+__name(validateSkillName, "validateSkillName");
+function qualifySkillName(extensionName, authoredName) {
+  return `${extensionName}:${authoredName}`;
+}
+__name(qualifySkillName, "qualifySkillName");
+function skillRestrictionNames(skill) {
+  const { name, authoredName } = skill;
+  const canonical = name.trim().toLowerCase();
+  const authored = authoredName?.trim().toLowerCase();
+  return authored && authored !== canonical ? [canonical, authored] : [canonical];
+}
+__name(skillRestrictionNames, "skillRestrictionNames");
+function authoredSkillName(skill) {
+  return skill.authoredName ?? skill.name;
+}
+__name(authoredSkillName, "authoredSkillName");
+var SkillError = class extends Error {
+  constructor(message, code, skillName) {
+    super(message);
+    this.code = code;
+    this.skillName = skillName;
+    this.name = "SkillError";
+  }
+  static {
+    __name(this, "SkillError");
+  }
+};
+var SkillErrorCode = {
+  NOT_FOUND: "NOT_FOUND",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  INVALID_NAME: "INVALID_NAME",
+  FILE_ERROR: "FILE_ERROR",
+  PARSE_ERROR: "PARSE_ERROR"
+};
 // packages/core/src/skills/skill-curator.ts
 init_esbuild_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
@@ -8733,102 +8844,6 @@ async function assertRealProjectSkillPath(targetPath, projectRoot) {
 }
 __name(assertRealProjectSkillPath, "assertRealProjectSkillPath");
-// packages/core/src/skills/types.ts
-init_esbuild_shims();
-function parseModelField(frontmatter) {
-  const raw = frontmatter["model"];
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "string") {
-    throw new Error('"model" must be a string');
-  }
-  const trimmed = raw.trim();
-  if (trimmed === "" || trimmed === "inherit") {
-    return void 0;
-  }
-  return trimmed;
-}
-__name(parseModelField, "parseModelField");
-function parseUserInvocableField(frontmatter) {
-  const raw = frontmatter["user-invocable"];
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (raw === true || raw === "true") {
-    return true;
-  }
-  if (raw === false || raw === "false") {
-    return false;
-  }
-  return void 0;
-}
-__name(parseUserInvocableField, "parseUserInvocableField");
-function parsePathsField(frontmatter) {
-  const raw = frontmatter["paths"];
-  if (raw === void 0 || raw === null) {
-    return void 0;
-  }
-  if (!Array.isArray(raw)) {
-    throw new Error('"paths" must be an array of glob patterns');
-  }
-  const cleaned = raw.map((p) => String(p).trim()).filter((p) => p.length > 0);
-  for (const pattern of cleaned) {
-    const normalized = pattern.replace(/\\/g, "/");
-    if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
-      throw new Error(
-        `"paths" entry "${pattern}" looks absolute; patterns are project-root-relative \u2014 drop the leading slash / drive letter`
-      );
-    }
-    const segments = normalized.split("/");
-    if (segments.some((seg) => seg === "..")) {
-      throw new Error(
-        `"paths" entry "${pattern}" contains a ".." segment that escapes the project root; patterns must stay within the project`
-      );
-    }
-  }
-  return cleaned.length > 0 ? cleaned : void 0;
-}
-__name(parsePathsField, "parsePathsField");
-var SKILL_NAME_PATTERN = /^[\p{L}\p{N}_:.-]+$/u;
-function parseAllowedToolsField(frontmatter) {
-  const raw = frontmatter["allowedTools"];
-  if (raw == null) {
-    return void 0;
-  }
-  if (!Array.isArray(raw)) {
-    throw new Error('"allowedTools" must be an array');
-  }
-  return raw.map(String);
-}
-__name(parseAllowedToolsField, "parseAllowedToolsField");
-function validateSkillName(name) {
-  if (!SKILL_NAME_PATTERN.test(name)) {
-    throw new Error(
-      `"name" must match ${SKILL_NAME_PATTERN} (letters, digits, _, :, ., -); got "${name}"`
-    );
-  }
-}
-__name(validateSkillName, "validateSkillName");
-var SkillError = class extends Error {
-  constructor(message, code, skillName) {
-    super(message);
-    this.code = code;
-    this.skillName = skillName;
-    this.name = "SkillError";
-  }
-  static {
-    __name(this, "SkillError");
-  }
-};
-var SkillErrorCode = {
-  NOT_FOUND: "NOT_FOUND",
-  INVALID_CONFIG: "INVALID_CONFIG",
-  INVALID_NAME: "INVALID_NAME",
-  FILE_ERROR: "FILE_ERROR",
-  PARSE_ERROR: "PARSE_ERROR"
-};
 // packages/core/src/skills/skill-curator.ts
 var AUTO_SKILL_CURATOR_INTERVAL_MS = 7 * 24 * 60 * 60 * 1e3;
 var AUTO_SKILL_STALE_AFTER_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -9588,6 +9603,9 @@ export {
   SKILL_NAME_PATTERN,
   parseAllowedToolsField,
   validateSkillName,
+  qualifySkillName,
+  skillRestrictionNames,
+  authoredSkillName,
   SkillError,
   SkillErrorCode,
   parse2 as parse,