@hasna/skills 0.1.53 → 0.1.55

package/bin/index.js

@@ -36860,7 +36860,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.1.53",
+    version: "0.1.55",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -38067,9 +38067,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"}`
     };
   }
@@ -38437,8 +38437,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" },
@@ -40153,6 +40153,13 @@ var init_project_management = __esm(() => {
       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"]
     }
   ];
 });
@@ -40530,14 +40537,14 @@ var init_data_analysis = __esm(() => {
       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",
@@ -43770,6 +43777,7 @@ var init_discovery = __esm(() => {
     "DALL-E 3",
     "GPT-4o Mini",
     "Cerebras",
+    "OpenRouter",
     "Firecrawl",
     "ElevenLabs",
     "Anthropic",
@@ -43798,6 +43806,7 @@ var init_discovery = __esm(() => {
     "google",
     "minimax",
     "openai",
+    "openrouter",
     "seedance",
     "whisper",
     "xai"
@@ -43811,6 +43820,7 @@ var init_discovery = __esm(() => {
     "GOOGLE_",
     "MINIMAX_",
     "OPENAI_",
+    "OPENROUTER_",
     "XAI_"
   ];
   VENDOR_PACKAGE_PATTERNS = [
@@ -43821,6 +43831,7 @@ var init_discovery = __esm(() => {
     /gemini/i,
     /minimax/i,
     /openai/i,
+    /openrouter/i,
     /xai/i
   ];
   vendorPattern = new RegExp(`\\b(${VENDOR_TERMS.map(escapeRegExp2).join("|")})\\b`, "gi");
@@ -59224,6 +59235,484 @@ var init_introspect = __esm(() => {
   init_discovery();
 });
 
+// src/lib/tool-primitives.ts
+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 matches2 = [];
+  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;
+    matches2.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");
+    matches2.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 (matches2.length === 0) {
+    const primitive = primitiveByName.get("project-artifacts");
+    matches2.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(matches2).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));
+}
+var TOOL_PRIMITIVE_SCHEMA_VERSION = 1, TOOL_PRIMITIVES, CATEGORY_RULES, NAME_RULES, KEYWORD_RULES, primitiveByName, HOSTED_RUNTIME_SKILL_NAMES;
+var init_tool_primitives = __esm(() => {
+  init_registry();
+  init_pricing();
+  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"]
+    }
+  ];
+  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." }
+  ];
+  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." }
+  ];
+  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." }
+  ];
+  primitiveByName = new Map(TOOL_PRIMITIVES.map((primitive) => [primitive.name, primitive]));
+  HOSTED_RUNTIME_SKILL_NAMES = new Set([
+    "audio",
+    "browse",
+    "convert",
+    "image",
+    "music",
+    "pdf-read",
+    "pdf-to-dataset",
+    "pdf-to-markdown",
+    "read-pdf",
+    "transcript",
+    "video",
+    "webcrawling"
+  ]);
+});
+
+// src/cli/commands/tool-primitives.ts
+var exports_tool_primitives = {};
+__export(exports_tool_primitives, {
+  registerToolPrimitives: () => registerToolPrimitives
+});
+function registerToolPrimitives(parent) {
+  const tools = parent.command("tools").description("Inspect primitive tools used by skills, CLI, MCP, and hosted runtimes");
+  tools.command("list").option("--json", "Output as JSON", false).option("--query <query>", "Filter by primitive name, family, runtime, or capability").description("List primitive tools").action((options) => {
+    const primitives = listToolPrimitives(options.query);
+    if (options.json) {
+      console.log(JSON.stringify({ schemaVersion: 1, primitives, total: primitives.length }, null, 2));
+      return;
+    }
+    for (const primitive of primitives) {
+      console.log(`${source_default.bold(primitive.name)} ${source_default.dim(`[${primitive.family}/${primitive.runtime}]`)}`);
+      console.log(`  ${primitive.description}`);
+    }
+  });
+  tools.command("info").argument("<primitive>", "Primitive tool name").option("--json", "Output as JSON", false).description("Show primitive tool details").action((name, options) => {
+    const primitive = getToolPrimitive(name);
+    if (!primitive) {
+      if (options.json)
+        console.log(JSON.stringify({ error: `Primitive '${name}' not found` }));
+      else
+        console.error(`Primitive '${name}' not found`);
+      process.exitCode = 1;
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(primitive, null, 2));
+      return;
+    }
+    console.log(`${source_default.bold(primitive.title)} ${source_default.dim(`[${primitive.name}]`)}`);
+    console.log(primitive.description);
+    console.log(`${source_default.dim("Family:")} ${primitive.family}`);
+    console.log(`${source_default.dim("Runtime:")} ${primitive.runtime}`);
+    if (primitive.capabilities.length)
+      console.log(`${source_default.dim("Capabilities:")} ${primitive.capabilities.join(", ")}`);
+    if (primitive.cliCommands.length)
+      console.log(`${source_default.dim("CLI:")} ${primitive.cliCommands.join(", ")}`);
+    if (primitive.mcpTools.length)
+      console.log(`${source_default.dim("MCP:")} ${primitive.mcpTools.join(", ")}`);
+  });
+  tools.command("deps").argument("<skill>", "Skill name").option("--json", "Output as JSON", false).description("Show primitive tool dependencies for a skill").action((name, options) => {
+    const deps = getSkillToolDependencies(name);
+    if (!deps) {
+      if (options.json)
+        console.log(JSON.stringify({ error: `Skill '${name}' not found` }));
+      else
+        console.error(`Skill '${name}' not found`);
+      process.exitCode = 1;
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(deps, null, 2));
+      return;
+    }
+    console.log(`${source_default.bold(deps.skill)} ${source_default.dim(`[${deps.category}]`)}`);
+    console.log(`${source_default.dim("Gateway backed:")} ${deps.gatewayBacked ? "yes" : "no"}`);
+    console.log(`${source_default.dim("Hosted runtime:")} ${deps.hostedRuntime ? "yes" : "no"}`);
+    for (const dependency of deps.dependencies) {
+      console.log(`  ${source_default.bold(dependency.primitive)} ${source_default.dim(`[${dependency.family}]`)} - ${dependency.reason}`);
+    }
+  });
+  tools.command("validate").option("--json", "Output as JSON", false).option("--profile <profile>", "Registry profile: basic or all", "all").description("Validate primitive tool coverage for the bundled skill catalog").action((options) => {
+    const profile = options.profile === "basic" ? "basic" : "all";
+    const result2 = validateToolPrimitiveCoverage(profile);
+    if (options.json) {
+      console.log(JSON.stringify(result2, null, 2));
+    } else if (result2.valid) {
+      console.log(source_default.green(`Primitive coverage ok: ${result2.mappedSkillCount}/${result2.skillCount} skills mapped to ${result2.primitiveCount} primitives`));
+      console.log(source_default.dim(`Gateway-backed: ${result2.gatewayBackedSkillCount}; hosted runtime: ${result2.hostedRuntimeSkillCount}`));
+    } else {
+      console.log(source_default.red(`Primitive coverage failed: ${result2.issues.length} issue(s)`));
+      for (const issue2 of result2.issues)
+        console.log(source_default.red(`  ${issue2.skill}: ${issue2.message}`));
+    }
+    if (!result2.valid)
+      process.exitCode = 1;
+  });
+}
+var init_tool_primitives2 = __esm(() => {
+  init_source();
+  init_tool_primitives();
+});
+
 // src/cli/commands/init.ts
 var exports_init = {};
 __export(exports_init, {
@@ -75157,7 +75646,7 @@ function listMcpToolContracts(query) {
     ].join(" ").toLowerCase();
     return haystack.includes(needle);
   }) : contracts;
-  return clone3(filtered);
+  return clone4(filtered);
 }
 function describeMcpToolContracts(names) {
   const byName = new Map(contracts.map((contract) => [contract.name, contract]));
@@ -75171,7 +75660,7 @@ function describeMcpToolContracts(names) {
         params: []
       };
     }
-    return { ...clone3(contract), known: true };
+    return { ...clone4(contract), known: true };
   });
 }
 function summarizeMcpToolContract(contract) {
@@ -75185,21 +75674,21 @@ function summarizeMcpToolContract(contract) {
   };
 }
 function getMcpResourceContracts() {
-  return clone3(resourceContracts);
+  return clone4(resourceContracts);
 }
 function createMcpContractManifest(options = {}) {
   const selectedNames = options.names ? new Set(options.names) : null;
   const tools = selectedNames ? contracts.filter((contract) => selectedNames.has(contract.name)) : contracts;
   return {
     schemaVersion: MCP_CONTRACT_SCHEMA_VERSION,
-    tools: clone3(tools),
+    tools: clone4(tools),
     resources: options.includeResources === false ? [] : getMcpResourceContracts()
   };
 }
 function createSkillMcpMetadata(skill) {
-  const installInput = clone3(getRequiredContract("pin_skill").inputSchema);
-  const runInput = clone3(getRequiredContract("run_skill").inputSchema);
-  const validateInput = clone3(getRequiredContract("validate_skill").inputSchema);
+  const installInput = clone4(getRequiredContract("pin_skill").inputSchema);
+  const runInput = clone4(getRequiredContract("run_skill").inputSchema);
+  const validateInput = clone4(getRequiredContract("validate_skill").inputSchema);
   installInput.properties = {
     ...installInput.properties,
     name: {
@@ -75238,17 +75727,17 @@ function createSkillMcpMetadata(skill) {
       install: {
         tool: "pin_skill",
         inputSchema: installInput,
-        outputSchema: clone3(getRequiredContract("pin_skill").outputSchema)
+        outputSchema: clone4(getRequiredContract("pin_skill").outputSchema)
       },
       run: {
         tool: "run_skill",
         inputSchema: runInput,
-        outputSchema: clone3(getRequiredContract("run_skill").outputSchema)
+        outputSchema: clone4(getRequiredContract("run_skill").outputSchema)
       },
       validate: {
         tool: "validate_skill",
         inputSchema: validateInput,
-        outputSchema: clone3(getRequiredContract("validate_skill").outputSchema)
+        outputSchema: clone4(getRequiredContract("validate_skill").outputSchema)
       }
     }
   };
@@ -75265,7 +75754,7 @@ function getRequiredContract(name) {
     throw new Error(`Missing MCP tool contract: ${name}`);
   return contract;
 }
-function clone3(value) {
+function clone4(value) {
   return JSON.parse(JSON.stringify(value));
 }
 var MCP_CONTRACT_SCHEMA_VERSION = 1, stringSchema = (description) => ({
@@ -75285,7 +75774,7 @@ var MCP_CONTRACT_SCHEMA_VERSION = 1, stringSchema = (description) => ({
   type: "array",
   items,
   ...description ? { description } : {}
-}), skillNameInput, optionalAgentInput, scopeInput, runInputSchema, runArgsSchema, paidRunApprovalSchema, errorSchema, pricingSchema, skillSummarySchema, validationMessageSchema, validationOutputSchema, installOutputSchema, runOutputSchema, toolContracts, contracts, resourceContracts;
+}), skillNameInput, optionalAgentInput, scopeInput, runInputSchema, runArgsSchema, paidRunApprovalSchema, errorSchema, pricingSchema, skillSummarySchema, toolPrimitiveSummarySchema, skillToolDependencySchema, validationMessageSchema, validationOutputSchema, installOutputSchema, runOutputSchema, toolContracts, contracts, resourceContracts;
 var init_mcp_contracts = __esm(() => {
   skillNameInput = stringSchema("skill name or alias.");
   optionalAgentInput = stringSchema("Optional target agent slug. Use MCP registration instead of direct skill-folder installs.");
@@ -75328,6 +75817,20 @@ var init_mcp_contracts = __esm(() => {
     category: stringSchema("Skill category."),
     pricing: pricingSchema
   }, ["name", "category"], "Compact skill summary.");
+  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.");
+  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.");
   validationMessageSchema = objectSchema({
     code: stringSchema("Stable validation code."),
     message: stringSchema("Validation message."),
@@ -75508,6 +76011,74 @@ var init_mcp_contracts = __esm(() => {
       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",
@@ -75900,6 +76471,13 @@ var init_mcp_contracts = __esm(() => {
       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",
@@ -76074,6 +76652,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")));
 }
 var init_discovery_tools = __esm(() => {
   init_zod();
@@ -76082,6 +76702,7 @@ var init_discovery_tools = __esm(() => {
   init_skillinfo();
   init_mcp_contracts();
   init_discovery();
+  init_tool_primitives();
   init_helpers();
 });
 
@@ -76750,6 +77371,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 }) => {
@@ -76768,6 +77398,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"
@@ -76851,6 +77482,7 @@ var init_resource_meta_tools = __esm(() => {
   init_feedback();
   init_mcp_contracts();
   init_discovery();
+  init_tool_primitives();
   init_helpers();
 });
 
@@ -85622,15 +86254,9 @@ function print(value, json, text) {
   else
     console.log(text);
 }
-function hasJsonOption(options) {
-  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
-}
-function wantsJson(actionOptions, command) {
-  return hasJsonOption(actionOptions) || hasJsonOption(command);
-}
 function registerWebhookCommands(program2, options) {
   const webhooks = program2.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
+  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions) => {
     const timestamp = new Date().toISOString();
     const channel = {
       id: actionOptions.id,
@@ -85651,11 +86277,11 @@ function registerWebhookCommands(program2, options) {
       throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
     }
     const saved = await createClient(options).addChannel(channel);
-    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
+    print(sanitizeChannelForOutput(saved), Boolean(actionOptions.json), `Added ${saved.transport} channel ${saved.id}`);
   });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
     const channels = await createClient(options).listChannels();
-    if (wantsJson(actionOptions, command)) {
+    if (actionOptions.json) {
       console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
       return;
     }
@@ -85667,11 +86293,11 @@ function registerWebhookCommands(program2, options) {
       console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
     }
   });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
     const removed = await createClient(options).removeChannel(id);
-    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
+    print({ removed }, Boolean(actionOptions.json), removed ? `Removed ${id}` : `Channel not found: ${id}`);
   });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
     const result2 = await createClient(options).testChannel(id, {
       source: options.source,
       type: actionOptions.type,
@@ -85679,13 +86305,13 @@ function registerWebhookCommands(program2, options) {
       message: actionOptions.message,
       data: parseJsonObject(actionOptions.data, { test: true })
     });
-    print(result2, wantsJson(actionOptions, command), `${result2.status}: ${result2.channelId}`);
+    print(result2, Boolean(actionOptions.json), `${result2.status}: ${result2.channelId}`);
   });
   return webhooks;
 }
 function registerEventCommands(program2, options) {
   const events = program2.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
-  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
+  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions) => {
     const result2 = await createClient(options).emit({
       source: actionOptions.source ?? options.source,
       type,
@@ -85696,9 +86322,9 @@ function registerEventCommands(program2, options) {
       data: parseJsonObject(actionOptions.data, {}),
       metadata: parseJsonObject(actionOptions.metadata, {})
     }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
-    print(result2, wantsJson(actionOptions, command), `${result2.deduped ? "Deduped" : "Emitted"} ${result2.event.id} to ${result2.deliveries.length} channel(s)`);
+    print(result2, Boolean(actionOptions.json), `${result2.deduped ? "Deduped" : "Emitted"} ${result2.event.id} to ${result2.deliveries.length} channel(s)`);
   });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
     let rows = await createClient(options).listEvents();
     if (actionOptions.source)
       rows = rows.filter((event) => event.source === actionOptions.source);
@@ -85706,7 +86332,7 @@ function registerEventCommands(program2, options) {
       rows = rows.filter((event) => event.type === actionOptions.type);
     if (actionOptions.limit)
       rows = rows.slice(-actionOptions.limit);
-    if (wantsJson(actionOptions, command)) {
+    if (actionOptions.json) {
       console.log(JSON.stringify(rows, null, 2));
       return;
     }
@@ -85717,14 +86343,14 @@ function registerEventCommands(program2, options) {
     for (const event of rows)
       console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
   });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
     const result2 = await createClient(options).replay({
       eventId: actionOptions.id,
       source: actionOptions.source,
       type: actionOptions.type,
       dryRun: actionOptions.dryRun
     });
-    print(result2, wantsJson(actionOptions, command), `Replayed ${result2.events.length} event(s), ${result2.deliveries.length} delivery result(s)`);
+    print(result2, Boolean(actionOptions.json), `Replayed ${result2.events.length} event(s), ${result2.deliveries.length} delivery result(s)`);
   });
   return events;
 }
@@ -86926,6 +87552,8 @@ var { registerBrowse: registerBrowse2 } = await Promise.resolve().then(() => (in
 registerBrowse2(program2);
 var { registerIntrospect: registerIntrospect2 } = await Promise.resolve().then(() => (init_introspect(), exports_introspect));
 registerIntrospect2(program2);
+var { registerToolPrimitives: registerToolPrimitives2 } = await Promise.resolve().then(() => (init_tool_primitives2(), exports_tool_primitives));
+registerToolPrimitives2(program2);
 var { registerSetup: registerSetup2 } = await Promise.resolve().then(() => (init_init(), exports_init));
 registerSetup2(program2);
 var { registerDiagnostic: registerDiagnostic2 } = await Promise.resolve().then(() => (init_diagnostic(), exports_diagnostic));