@hasna/skills 0.1.53 → 0.1.55

package/bin/mcp.js

@@ -6697,9 +6697,9 @@ function getSkillRunPricing(slug, input, args = []) {
       tier: "premium",
       costCents: ARTICLE_USER_COST_CENTS * count,
       costMicros: ARTICLE_INTERNAL_COST_CENTS * count * 1e4,
-      provider: "cerebras",
-      model: "gpt-oss",
-      providers: ["cerebras"],
+      provider: "openrouter",
+      model: "openai/gpt-4o-mini",
+      providers: ["openrouter"],
       description: `Remote article generation; ${count} article${count === 1 ? "" : "s"}`
     };
   }
@@ -7067,8 +7067,8 @@ var init_pricing = __esm(() => {
     { slug: "transcript", displayName: "Transcript", tier: "premium", costCents: 10, providers: ["openai", "elevenlabs", "deepgram", "hosted"], description: "Audio/video transcription with timestamps, diarization, and URL support" },
     { slug: "webcrawling", displayName: "Web Crawling", tier: "premium", costCents: 5, providers: ["firecrawl"], description: "Structured web page crawling and extraction" },
     { slug: "browse", displayName: "Browse", tier: "premium", costCents: 5, providers: ["browser"], description: "Web browsing and page interaction" },
-    { slug: "read-pdf", displayName: "Read PDF", tier: "premium", costCents: 5, providers: ["cerebras"], description: "Hosted PDF extraction and structured content analysis" },
-    { slug: "pdf-read", displayName: "PDF Read", tier: "premium", costCents: 5, providers: ["cerebras"], description: "Hosted multi-PDF text extraction with page ranges" },
+    { slug: "read-pdf", displayName: "Read PDF", tier: "premium", costCents: 5, providers: ["openrouter"], description: "Hosted PDF extraction and structured content analysis" },
+    { slug: "pdf-read", displayName: "PDF Read", tier: "premium", costCents: 5, providers: ["openrouter"], description: "Hosted multi-PDF text extraction with page ranges" },
     { slug: "pdf-to-markdown", displayName: "PDF to Markdown", tier: "premium", costCents: 5, providers: ["hosted"], description: "Hosted PDF to markdown conversion and cleanup" },
     { slug: "pdf-to-dataset", displayName: "PDF to Dataset", tier: "premium", costCents: 15, providers: ["hosted"], description: "Hosted PDF table and form extraction into CSV/JSON datasets" },
     { slug: "market-research-report", displayName: "Market Research Report", tier: "premium", costCents: 150, providers: ["hosted"], description: "Hosted market research report with competitor, audience, pricing, and source artifacts" },
@@ -21819,7 +21819,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.53",
+  version: "0.1.55",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -31150,6 +31150,13 @@ var PROJECT_MANAGEMENT_SKILLS = [
     description: "Create, validate, and serve standardized Hasna project dashboard reports",
     category: "Project Management",
     tags: ["projects", "dashboard", "reports", "json-render"]
+  },
+  {
+    name: "todos-plan",
+    displayName: "Todos Plan",
+    description: "Author, sync, route, and verify Todos plans using Todos CLI plan IDs as source of truth",
+    category: "Project Management",
+    tags: ["todos", "plans", "tasks", "verification", "workflow"]
   }
 ];
 
@@ -31518,14 +31525,14 @@ var DATA_ANALYSIS_SKILLS = [
     displayName: "Read PDF",
     description: "Extract text and structured content from PDF files with chunked Claude document analysis",
     category: "Data & Analysis",
-    tags: ["pdf", "documents", "extraction", "analysis", "remote", "premium", "cerebras"]
+    tags: ["pdf", "documents", "extraction", "analysis", "remote", "premium", "gateway"]
   },
   {
     name: "pdf-read",
     displayName: "PDF Read",
     description: "Read multiple PDFs with page-range selection, chunked reading, and parallel processing",
     category: "Data & Analysis",
-    tags: ["pdf", "reader", "extraction", "parallel", "remote", "premium", "cerebras"]
+    tags: ["pdf", "reader", "extraction", "parallel", "remote", "premium", "gateway"]
   },
   {
     name: "pdf-to-markdown",
@@ -33054,6 +33061,20 @@ var skillSummarySchema = objectSchema({
   category: stringSchema("Skill category."),
   pricing: pricingSchema
 }, ["name", "category"], "Compact skill summary.");
+var toolPrimitiveSummarySchema = objectSchema({
+  name: stringSchema("Primitive tool name."),
+  title: stringSchema("Display name."),
+  family: stringSchema("Primitive family."),
+  runtime: stringSchema("Runtime type: local, hosted, gateway, connector, or mixed."),
+  description: stringSchema("Primitive description.")
+}, ["name", "title", "family", "runtime", "description"], "Primitive tool summary.");
+var skillToolDependencySchema = objectSchema({
+  skill: stringSchema("Skill slug."),
+  primitive: stringSchema("Primitive tool name."),
+  family: stringSchema("Primitive family."),
+  required: { type: "boolean" },
+  reason: stringSchema("Why this skill depends on the primitive.")
+}, ["skill", "primitive", "family", "required", "reason"], "Primitive dependency for a skill.");
 var validationMessageSchema = objectSchema({
   code: stringSchema("Stable validation code."),
   message: stringSchema("Validation message."),
@@ -33234,6 +33255,74 @@ var toolContracts = [
     inputSchema: objectSchema({ name: skillNameInput }, ["name"]),
     outputSchema: { type: "string", description: "Best available skill documentation." }
   },
+  {
+    name: "list_tool_primitives",
+    title: "List Tool Primitives",
+    description: "List primitive tools used by skills across CLI, MCP, API, and hosted worker execution.",
+    params: ["query?"],
+    category: "discovery",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ query: stringSchema("Optional primitive search query.") }),
+    outputSchema: objectSchema({
+      schemaVersion: { type: "number" },
+      primitives: arraySchema(toolPrimitiveSummarySchema),
+      total: { type: "number" }
+    }, ["schemaVersion", "primitives", "total"])
+  },
+  {
+    name: "get_tool_primitive",
+    title: "Get Tool Primitive",
+    description: "Get one primitive tool definition by name.",
+    params: ["name"],
+    category: "metadata",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ name: stringSchema("Primitive tool name.") }, ["name"]),
+    outputSchema: objectSchema({}, [], "Primitive tool definition.", true)
+  },
+  {
+    name: "get_skill_tool_dependencies",
+    title: "Get Skill Tool Dependencies",
+    description: "Get primitive tool dependencies for one skill.",
+    params: ["name"],
+    category: "metadata",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ name: skillNameInput }, ["name"]),
+    outputSchema: objectSchema({
+      schemaVersion: { type: "number" },
+      skill: skillNameInput,
+      category: stringSchema("Skill category."),
+      source: stringSchema("Skill source."),
+      dependencies: arraySchema(skillToolDependencySchema),
+      gatewayBacked: { type: "boolean" },
+      hostedRuntime: { type: "boolean" }
+    }, ["schemaVersion", "skill", "category", "dependencies", "gatewayBacked", "hostedRuntime"])
+  },
+  {
+    name: "validate_tool_primitives",
+    title: "Validate Tool Primitives",
+    description: "Validate primitive tool coverage for the bundled skill catalog.",
+    params: ["profile?"],
+    category: "validation",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({
+      profile: { type: "string", enum: ["basic", "all"], default: "all" }
+    }),
+    outputSchema: objectSchema({
+      schemaVersion: { type: "number" },
+      valid: { type: "boolean" },
+      profile: stringSchema("Registry profile."),
+      skillCount: { type: "number" },
+      primitiveCount: { type: "number" },
+      mappedSkillCount: { type: "number" },
+      gatewayBackedSkillCount: { type: "number" },
+      hostedRuntimeSkillCount: { type: "number" },
+      issues: arraySchema(objectSchema({}, [], "Coverage issue.", true))
+    }, ["schemaVersion", "valid", "profile", "skillCount", "primitiveCount", "mappedSkillCount", "issues"])
+  },
   {
     name: "pin_skill",
     title: "Pin Skill",
@@ -33626,6 +33715,13 @@ var resourceContracts = [
     mimeType: "application/json",
     schema: arraySchema(skillSummarySchema)
   },
+  {
+    uri: "skills://tool-primitives",
+    name: "Tool Primitives",
+    description: "Primitive tool catalog used by skills across CLI, MCP, API, and hosted workers.",
+    mimeType: "application/json",
+    schema: arraySchema(toolPrimitiveSummarySchema)
+  },
   {
     uri: "skills://{name}",
     name: "Skill Info",
@@ -33769,6 +33865,7 @@ var VENDOR_TERMS = [
   "DALL-E 3",
   "GPT-4o Mini",
   "Cerebras",
+  "OpenRouter",
   "Firecrawl",
   "ElevenLabs",
   "Anthropic",
@@ -33797,6 +33894,7 @@ var VENDOR_TAGS = new Set([
   "google",
   "minimax",
   "openai",
+  "openrouter",
   "seedance",
   "whisper",
   "xai"
@@ -33810,6 +33908,7 @@ var VENDOR_ENV_PREFIXES = [
   "GOOGLE_",
   "MINIMAX_",
   "OPENAI_",
+  "OPENROUTER_",
   "XAI_"
 ];
 var VENDOR_PACKAGE_PATTERNS = [
@@ -33820,6 +33919,7 @@ var VENDOR_PACKAGE_PATTERNS = [
   /gemini/i,
   /minimax/i,
   /openai/i,
+  /openrouter/i,
   /xai/i
 ];
 var vendorPattern = new RegExp(`\\b(${VENDOR_TERMS.map(escapeRegExp).join("|")})\\b`, "gi");
@@ -33882,6 +33982,395 @@ function resolveDiscoveryPricing(skill) {
   return skill.pricing && typeof skill.pricing.formattedCost === "string" ? skill.pricing : getPublicSkillPricing(skill.name);
 }
 
+// src/lib/tool-primitives.ts
+init_pricing();
+var TOOL_PRIMITIVE_SCHEMA_VERSION = 1;
+var TOOL_PRIMITIVES = [
+  {
+    name: "ai-gateway",
+    title: "AI Gateway",
+    family: "ai",
+    description: "Provider-neutral text, code, reasoning, and multimodal model calls routed through the configured hosted gateway.",
+    runtime: "gateway",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "SkillRunRecord", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["text", "json", "markdown", "artifact"],
+    capabilities: ["completion", "reasoning", "tool-calling", "vision-input", "structured-output"]
+  },
+  {
+    name: "documents-read",
+    title: "Document Read",
+    family: "documents",
+    description: "Read, parse, normalize, and extract from PDF, DOCX, slides, invoices, contracts, and other document files.",
+    runtime: "mixed",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["getSkillRequirements", "runSkill"],
+    envVars: [],
+    outputTypes: ["text", "json", "markdown"],
+    capabilities: ["pdf-parse", "office-parse", "ocr", "metadata-extraction"]
+  },
+  {
+    name: "documents-write",
+    title: "Document Write",
+    family: "documents",
+    description: "Generate PDFs, DOCX, slide decks, ebooks, reports, and other downloadable document artifacts.",
+    runtime: "mixed",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["createSkillRun", "completeSkillRun", "writeRunLogs"],
+    envVars: [],
+    outputTypes: ["pdf", "docx", "pptx", "markdown", "zip"],
+    capabilities: ["document-generation", "layout", "export-artifacts"]
+  },
+  {
+    name: "structured-data",
+    title: "Structured Data",
+    family: "data",
+    description: "Read, transform, validate, and export CSV, Excel, JSON, SQL, metrics, and tabular datasets.",
+    runtime: "mixed",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "SkillRunArtifact"],
+    envVars: [],
+    outputTypes: ["csv", "xlsx", "json", "sql", "markdown"],
+    capabilities: ["csv", "excel", "etl", "schema", "analytics"]
+  },
+  {
+    name: "media-image",
+    title: "Image Tooling",
+    family: "media",
+    description: "Generate, inspect, transform, remove backgrounds from, and package image artifacts.",
+    runtime: "gateway",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["png", "jpeg", "webp", "svg", "zip"],
+    capabilities: ["image-generation", "image-analysis", "image-editing", "asset-packaging"]
+  },
+  {
+    name: "media-audio",
+    title: "Audio Tooling",
+    family: "media",
+    description: "Transcribe, extract, clean, generate, and package audio, voiceover, music, and podcast outputs.",
+    runtime: "gateway",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["mp3", "wav", "txt", "srt", "json", "zip"],
+    capabilities: ["transcription", "audio-generation", "voiceover", "audio-cleanup"]
+  },
+  {
+    name: "media-video",
+    title: "Video Tooling",
+    family: "media",
+    description: "Generate, analyze, cut, caption, summarize, thumbnail, and package video outputs.",
+    runtime: "gateway",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["mp4", "mov", "srt", "png", "json", "zip"],
+    capabilities: ["video-generation", "video-analysis", "captioning", "highlight-extraction"]
+  },
+  {
+    name: "web-browser",
+    title: "Web Browser",
+    family: "web",
+    description: "Browse, crawl, search, screenshot, inspect, and analyze websites and web application states.",
+    runtime: "mixed",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["runSkill", "SkillRunArtifact"],
+    envVars: [],
+    outputTypes: ["html", "markdown", "png", "json", "har"],
+    capabilities: ["crawl", "browser-automation", "screenshots", "site-analysis"]
+  },
+  {
+    name: "connectors-run",
+    title: "Connector Operations",
+    family: "connectors",
+    description: "Declare and execute external account operations through approved connector plans instead of direct provider CLIs.",
+    runtime: "connector",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["SkillRunContext", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["json", "artifact"],
+    capabilities: ["approval", "external-api", "account-scoped-execution"]
+  },
+  {
+    name: "project-artifacts",
+    title: "Project Artifacts",
+    family: "workspace",
+    description: "Read project context and write deterministic run logs, exports, and downloadable artifacts.",
+    runtime: "local",
+    stable: true,
+    cliCommands: ["skills tools deps <skill>", "skills run <skill>"],
+    mcpTools: ["get_skill_tool_dependencies", "run_skill"],
+    apiSurfaces: ["createSkillRun", "completeSkillRun", "writeRunLogs", "SkillRunArtifact"],
+    envVars: [],
+    outputTypes: ["log", "json", "markdown", "file"],
+    capabilities: ["filesystem", "run-state", "artifact-export", "deterministic-logs"]
+  },
+  {
+    name: "safety-approval",
+    title: "Safety And Approval",
+    family: "safety",
+    description: "Gate risky, paid, security-sensitive, or compliance-sensitive skill actions behind explicit approval and structured evidence.",
+    runtime: "mixed",
+    stable: true,
+    cliCommands: ["skills quote <skill>", "skills tools deps <skill>"],
+    mcpTools: ["quote_skill", "get_skill_tool_dependencies"],
+    apiSurfaces: ["getSkillPricing", "getSkillRunCostCents", "validateSkillDirectory"],
+    envVars: [],
+    outputTypes: ["json", "markdown"],
+    capabilities: ["pricing-approval", "risk-review", "policy-evidence", "validation"]
+  },
+  {
+    name: "hosted-auth",
+    title: "Hosted Auth",
+    family: "hosted",
+    description: "Authenticate hosted and premium runs through Skills account credentials rather than local provider keys.",
+    runtime: "hosted",
+    stable: true,
+    cliCommands: ["skills auth login", "skills billing status", "skills run <skill>"],
+    mcpTools: ["run_skill", "quote_skill"],
+    apiSurfaces: ["RemoteSkillsClient", "RemoteSkillRunContract"],
+    envVars: ["SKILLS_API_KEY"],
+    outputTypes: ["json"],
+    capabilities: ["account-auth", "billing", "remote-run-submit"]
+  }
+];
+var CATEGORY_RULES = [
+  { primitive: "ai-gateway", categories: ["Business & Marketing", "Content Generation", "Design & Branding", "Research & Writing", "Education & Learning", "Communication", "Health & Wellness", "Travel & Lifestyle", "Event Management", "Science & Academic"], reason: "Category is primarily AI-assisted generation, analysis, or planning." },
+  { primitive: "project-artifacts", categories: ["Development Tools", "Project Management", "Productivity & Organization"], reason: "Category operates on project context, run logs, or workspace artifacts." },
+  { primitive: "structured-data", categories: ["Data & Analysis", "Finance & Compliance", "Science & Academic"], reason: "Category works with structured inputs, tabular evidence, metrics, or analytical outputs." },
+  { primitive: "safety-approval", categories: ["Finance & Compliance"], reason: "Category has compliance-sensitive outputs that need reviewable evidence." },
+  { primitive: "web-browser", categories: ["Web & Browser"], reason: "Category depends on browser, crawl, search, or web inspection primitives." },
+  { primitive: "media-image", categories: ["Media Processing", "Design & Branding"], reason: "Category includes visual asset generation, inspection, or packaging." }
+];
+var NAME_RULES = [
+  { primitive: "documents-read", names: ["read-pdf", "pdf-read", "pdf-to-markdown", "pdf-to-dataset", "doc-read", "extract-invoice", "contract-review-report", "invoice-reconciliation"], reason: "Skill explicitly reads or extracts from document files." },
+  { primitive: "documents-write", names: ["pdf-generate", "doc-generate", "generate-presentation", "slide-deck-generator", "pitch-deck", "proposal-pack", "create-ebook", "generate-book-cover", "api-docs-portal", "landing-page-pack", "one-page-website"], reason: "Skill generates downloadable documents or presentation artifacts." },
+  { primitive: "structured-data", names: ["read-csv", "read-excel", "excel", "generate-sql", "generate-mock-data", "benchmark-finder", "budget-variance-analyzer", "subscription-spend-watcher", "payroll-change-prepper"], reason: "Skill reads, creates, or analyzes structured data." },
+  { primitive: "media-image", names: ["image", "read-image", "brand-photo-shoot", "campaign-moodboard", "logo-design", "icon-pack", "emoji", "product-mockup", "photo-album", "remove-background", "video-thumbnail", "banner-ad-suite", "ad-creative-generator", "ad-creative-pack", "print-collateral-designer", "packaging-concept-studio"], reason: "Skill works directly with image or visual asset primitives." },
+  { primitive: "media-audio", names: ["audio", "music", "transcript", "audio-extract", "audio-transcript-pack", "music-album", "voiceover-jingle-pack", "podcast-show-notes", "subtitle", "audio-cleanup-lab"], reason: "Skill works directly with audio, music, voiceover, or transcription primitives." },
+  { primitive: "media-video", names: ["video", "short-video-pack", "video-highlight-pack", "video-cut-suggester", "video-thumbnail"], reason: "Skill works directly with video generation, editing, captions, or thumbnails." },
+  { primitive: "web-browser", names: ["browse", "webcrawling", "siteanalyze", "performance-audit-report", "seo-content-pack", "competitor-ad-analyzer", "security-audit-report"], reason: "Skill needs live web, crawl, browser, or site inspection primitives." },
+  { primitive: "connectors-run", names: ["email-sequence", "meeting-pack", "customer-feedback-report", "inbox-priority-planner", "crm-note-enhancer", "campaign-metric-brief"], reason: "Skill can execute account-scoped external communication or CRM operations." },
+  { primitive: "safety-approval", names: ["security-audit-report", "contract-review-report", "risk-disclosure-kit", "compliance-report-pack", "procurement-scorecard"], reason: "Skill produces security, legal, compliance, or procurement-sensitive evidence." }
+];
+var KEYWORD_RULES = [
+  { primitive: "documents-read", keywords: ["pdf", "docx", "document", "invoice", "contract"], reason: "Skill metadata references document parsing or review." },
+  { primitive: "documents-write", keywords: ["deck", "presentation", "report", "proposal", "ebook", "pdf"], reason: "Skill metadata references generated document artifacts." },
+  { primitive: "structured-data", keywords: ["csv", "excel", "spreadsheet", "dataset", "sql", "metric", "analytics", "scorecard", "budget"], reason: "Skill metadata references tabular or analytical data." },
+  { primitive: "media-image", keywords: ["image", "photo", "logo", "icon", "thumbnail", "visual", "ad creative", "mockup"], reason: "Skill metadata references image or visual assets." },
+  { primitive: "media-audio", keywords: ["audio", "voice", "music", "podcast", "transcript", "subtitle"], reason: "Skill metadata references audio or transcript assets." },
+  { primitive: "media-video", keywords: ["video", "clip", "caption", "highlight"], reason: "Skill metadata references video assets." },
+  { primitive: "web-browser", keywords: ["web", "website", "browser", "crawl", "seo", "landing page", "site"], reason: "Skill metadata references web or browser work." },
+  { primitive: "connectors-run", keywords: ["email", "calendar", "crm", "inbox", "meeting", "outreach"], reason: "Skill metadata references external account operations." }
+];
+var primitiveByName = new Map(TOOL_PRIMITIVES.map((primitive) => [primitive.name, primitive]));
+var HOSTED_RUNTIME_SKILL_NAMES = new Set([
+  "audio",
+  "browse",
+  "convert",
+  "image",
+  "music",
+  "pdf-read",
+  "pdf-to-dataset",
+  "pdf-to-markdown",
+  "read-pdf",
+  "transcript",
+  "video",
+  "webcrawling"
+]);
+function listToolPrimitives(query) {
+  const needle = query?.trim().toLowerCase();
+  return TOOL_PRIMITIVES.filter((primitive) => !needle || primitiveHaystack(primitive).includes(needle)).map(summarizeToolPrimitive).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getToolPrimitive(name) {
+  return clone3(primitiveByName.get(name));
+}
+function getSkillToolDependencies(name) {
+  const skill = getSkill(name);
+  if (!skill)
+    return null;
+  return createSkillToolDependencies(skill);
+}
+function createSkillToolDependencies(skill) {
+  const dependencies = inferPrimitiveDependencies(skill);
+  const primitiveNames = new Set(dependencies.map((dependency) => dependency.primitive));
+  return {
+    schemaVersion: TOOL_PRIMITIVE_SCHEMA_VERSION,
+    skill: skill.name,
+    category: skill.category,
+    source: skill.source ?? "official",
+    dependencies,
+    gatewayBacked: [...primitiveNames].some((name) => primitiveByName.get(name)?.runtime === "gateway" || name === "ai-gateway"),
+    hostedRuntime: isHostedRuntimeSkill(skill) || primitiveNames.has("hosted-auth")
+  };
+}
+function validateToolPrimitiveCoverage(profile = "all") {
+  const skills = loadRegistryProfile(profile);
+  const issues = [];
+  let mappedSkillCount = 0;
+  let gatewayBackedSkillCount = 0;
+  let hostedRuntimeSkillCount = 0;
+  for (const skill of skills) {
+    const deps = createSkillToolDependencies(skill);
+    if (deps.dependencies.length === 0) {
+      issues.push({
+        skill: skill.name,
+        code: "skill.unmapped",
+        message: `Skill '${skill.name}' has no primitive dependencies.`
+      });
+      continue;
+    }
+    mappedSkillCount++;
+    if (deps.gatewayBacked)
+      gatewayBackedSkillCount++;
+    if (deps.hostedRuntime)
+      hostedRuntimeSkillCount++;
+    for (const dependency of deps.dependencies) {
+      if (!primitiveByName.has(dependency.primitive)) {
+        issues.push({
+          skill: skill.name,
+          code: "primitive.missing",
+          message: `Skill '${skill.name}' references missing primitive '${dependency.primitive}'.`
+        });
+      }
+    }
+  }
+  return {
+    schemaVersion: TOOL_PRIMITIVE_SCHEMA_VERSION,
+    valid: issues.length === 0,
+    profile,
+    skillCount: skills.length,
+    primitiveCount: TOOL_PRIMITIVES.length,
+    mappedSkillCount,
+    gatewayBackedSkillCount,
+    hostedRuntimeSkillCount,
+    issues
+  };
+}
+function inferPrimitiveDependencies(skill) {
+  const matches = [];
+  const allRules = [...CATEGORY_RULES, ...NAME_RULES, ...KEYWORD_RULES];
+  for (const rule of allRules) {
+    if (!ruleMatches(skill, rule))
+      continue;
+    const primitive = primitiveByName.get(rule.primitive);
+    if (!primitive)
+      continue;
+    matches.push({
+      skill: skill.name,
+      primitive: primitive.name,
+      family: primitive.family,
+      required: rule.required ?? true,
+      reason: rule.reason
+    });
+  }
+  if (isHostedRuntimeSkill(skill)) {
+    const primitive = primitiveByName.get("hosted-auth");
+    matches.push({
+      skill: skill.name,
+      primitive: primitive.name,
+      family: primitive.family,
+      required: true,
+      reason: "Skill is premium, remote, or hosted and must use Skills account authentication."
+    });
+  }
+  if (matches.length === 0) {
+    const primitive = primitiveByName.get("project-artifacts");
+    matches.push({
+      skill: skill.name,
+      primitive: primitive.name,
+      family: primitive.family,
+      required: true,
+      reason: "Default workspace primitive for local skill execution, run logs, and artifacts."
+    });
+  }
+  return dedupeDependencies(matches).sort((a, b) => a.primitive.localeCompare(b.primitive));
+}
+function ruleMatches(skill, rule) {
+  const name = skill.name.toLowerCase();
+  const category = skill.category.toLowerCase();
+  const tags = skill.tags.map((tag) => tag.toLowerCase());
+  const haystack = [
+    skill.name,
+    skill.displayName,
+    skill.description,
+    skill.category,
+    ...skill.tags
+  ].join(" ").toLowerCase();
+  if (rule.names?.some((candidate) => candidate.toLowerCase() === name))
+    return true;
+  if (rule.categories?.some((candidate) => candidate.toLowerCase() === category))
+    return true;
+  if (rule.tags?.some((candidate) => tags.includes(candidate.toLowerCase())))
+    return true;
+  if (rule.keywords?.some((keyword) => haystack.includes(keyword.toLowerCase())))
+    return true;
+  return false;
+}
+function isHostedRuntimeSkill(skill) {
+  const tags = new Set(skill.tags.map((tag) => tag.toLowerCase()));
+  return isPremiumSkill(skill.name) || HOSTED_RUNTIME_SKILL_NAMES.has(skill.name) || tags.has("premium") || tags.has("remote") || tags.has("hosted") || skill.pricing?.tier === "premium";
+}
+function dedupeDependencies(dependencies) {
+  const byPrimitive = new Map;
+  for (const dependency of dependencies) {
+    const existing = byPrimitive.get(dependency.primitive);
+    if (!existing) {
+      byPrimitive.set(dependency.primitive, dependency);
+      continue;
+    }
+    byPrimitive.set(dependency.primitive, {
+      ...existing,
+      required: existing.required || dependency.required,
+      reason: existing.reason === dependency.reason ? existing.reason : `${existing.reason} ${dependency.reason}`
+    });
+  }
+  return [...byPrimitive.values()];
+}
+function summarizeToolPrimitive(primitive) {
+  return {
+    name: primitive.name,
+    title: primitive.title,
+    family: primitive.family,
+    runtime: primitive.runtime,
+    description: primitive.description
+  };
+}
+function primitiveHaystack(primitive) {
+  return [
+    primitive.name,
+    primitive.title,
+    primitive.family,
+    primitive.description,
+    primitive.runtime,
+    ...primitive.capabilities
+  ].join(" ").toLowerCase();
+}
+function clone3(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
 // src/lib/compact-output.ts
 var DEFAULT_MCP_LIMIT = 25;
 var MAX_PAGE_LIMIT = 200;
@@ -34127,6 +34616,48 @@ function registerDiscoveryTools(server) {
     }
     return { content: [{ type: "text", text: doc2 }] };
   });
+  server.registerTool("list_tool_primitives", {
+    title: "List Tool Primitives",
+    description: "List primitive tools that skills depend on across CLI, MCP, API, and hosted worker execution.",
+    inputSchema: {
+      query: exports_external.string().optional()
+    }
+  }, async ({ query }) => mcpJson({
+    schemaVersion: 1,
+    primitives: listToolPrimitives(query),
+    total: listToolPrimitives(query).length
+  }));
+  server.registerTool("get_tool_primitive", {
+    title: "Get Tool Primitive",
+    description: "Get one primitive tool definition by name.",
+    inputSchema: {
+      name: exports_external.string()
+    }
+  }, async ({ name }) => {
+    const primitive = getToolPrimitive(name);
+    if (!primitive)
+      return mcpError("PRIMITIVE_NOT_FOUND", `Primitive '${name}' not found`);
+    return mcpJson(primitive);
+  });
+  server.registerTool("get_skill_tool_dependencies", {
+    title: "Get Skill Tool Dependencies",
+    description: "Get primitive tool dependencies for one skill.",
+    inputSchema: {
+      name: exports_external.string()
+    }
+  }, async ({ name }) => {
+    const deps = getSkillToolDependencies(name);
+    if (!deps)
+      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
+    return mcpJson(deps);
+  });
+  server.registerTool("validate_tool_primitives", {
+    title: "Validate Tool Primitives",
+    description: "Validate primitive tool coverage for the bundled skill catalog.",
+    inputSchema: {
+      profile: exports_external.enum(["basic", "all"]).optional()
+    }
+  }, async ({ profile }) => mcpJson(validateToolPrimitiveCoverage(profile || "all")));
 }
 
 // src/mcp/operation-tools.ts
@@ -34860,6 +35391,15 @@ function registerResourceMetaTools(server) {
       mimeType: "application/json"
     }]
   }));
+  server.registerResource("Tool Primitives", "skills://tool-primitives", {
+    description: "Primitive tool catalog used by skills across CLI, MCP, API, and hosted workers."
+  }, async () => ({
+    contents: [{
+      uri: "skills://tool-primitives",
+      text: JSON.stringify(listToolPrimitives(), null, 2),
+      mimeType: "application/json"
+    }]
+  }));
   server.registerResource("Skill Info", new ResourceTemplate("skills://{name}", { list: undefined }), {
     description: "Individual skill metadata and documentation"
   }, async (uri, { name }) => {
@@ -34878,6 +35418,7 @@ function registerResourceMetaTools(server) {
           ...skill ? getPublicSkillDiscovery(skill) : {},
           documentation: skill ? publicDiscoveryDocumentation(skill, doc2) : doc2,
           requirements: publicReqs,
+          toolDependencies: skill ? getSkillToolDependencies(skill.name) : null,
           ...skill ? { mcp: createSkillMcpMetadata(getPublicSkillDiscovery(skill)) } : {}
         }, null, 2),
         mimeType: "application/json"