agentwheel 0.18.5 → 0.19.0

package/dist/index.js

@@ -56,6 +56,18 @@ var packageComposeEntrySchema = z.object({
   markers: z.boolean().optional(),
   optional: z.boolean().optional()
 });
+var packageCompositionRuleSchema = z.object({
+  target: z.string().min(1),
+  include: z.string().min(1),
+  exclude: z.array(z.string().min(1)).optional(),
+  runtimes: z.array(z.string().min(1)).optional(),
+  markers: z.boolean().optional()
+});
+var packageSupersedesEntrySchema = z.object({
+  package: z.string().min(1),
+  selector: z.string().min(1),
+  reason: z.string().min(1)
+});
 var packageItemRequireObjectSchema = z.object({
   selector: z.string().min(1),
   optional: z.boolean().optional(),
@@ -97,6 +109,7 @@ var artifactSchema = z.object({
   requires: z.array(packageItemRequireSchema).optional(),
   suggests: z.array(packageItemSuggestSchema).optional(),
   compose: z.array(packageComposeEntrySchema).optional(),
+  supersedes: z.array(packageSupersedesEntrySchema).optional(),
   runtimes: z.array(z.string().min(1)).optional(),
   composedFrom: z.array(composedFromEntrySchema).optional()
 });
@@ -580,7 +593,8 @@ var graphLockArtifactSchema = z4.object({
   kind: fileKindSchema,
   hash: z4.string().min(16),
   channel: z4.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed"),
-  composedFrom: z4.array(composedFromEntrySchema).optional()
+  composedFrom: z4.array(composedFromEntrySchema).optional(),
+  supersedes: z4.array(packageSupersedesEntrySchema).optional()
 });
 var graphLockPlainNameIncumbentSchema = z4.object({
   adapter: z4.string().min(1),
@@ -5638,7 +5652,7 @@ var legacyArtifactTypeSchema = z6.enum([
   "plugins"
 ]);
 var runtimeListSchema = z6.array(z6.string().min(1));
-var CURRENT_OPENPACK_SCHEMA_VERSION = 2;
+var CURRENT_OPENPACK_SCHEMA_VERSION = 3;
 var packageProvideBaseSchema = z6.object({
   path: z6.string().min(1),
   format: artifactFormatSchema.optional(),
@@ -5650,6 +5664,7 @@ var packageItemSchema = z6.object({
   requires: z6.array(packageItemRequireSchema).optional(),
   suggests: z6.array(packageItemSuggestSchema).optional(),
   compose: z6.array(packageComposeEntrySchema).optional(),
+  supersedes: z6.array(packageSupersedesEntrySchema).optional(),
   runtimes: runtimeListSchema.optional()
 });
 var packageDependencySchema = z6.object({
@@ -5680,8 +5695,7 @@ var packageManifestV1Schema = z6.object({
   version: z6.string().min(1),
   provides: z6.array(packageProvideV1Schema).min(1)
 });
-var packageManifestV2Schema = z6.object({
-  schemaVersion: z6.literal(CURRENT_OPENPACK_SCHEMA_VERSION),
+var packageManifestModernShape = {
   name: z6.string().min(1),
   version: z6.string().min(1),
   runtimes: runtimeListSchema.optional(),
@@ -5689,7 +5703,8 @@ var packageManifestV2Schema = z6.object({
   suggests: z6.record(z6.string().min(1), packageSuggestionSchema).optional(),
   compose: z6.array(packageComposeEntrySchema).optional(),
   provides: z6.array(packageProvideSchema).default([])
-}).superRefine((manifest, ctx) => {
+};
+function requireProvidesOrDependencies(manifest, ctx) {
   const hasProvides = manifest.provides.length > 0;
   const hasRequires = Object.keys(manifest.requires ?? {}).length > 0;
   if (!hasProvides && !hasRequires) {
@@ -5699,8 +5714,17 @@ var packageManifestV2Schema = z6.object({
       message: "OpenPack v2 manifest must declare at least one provides entry or one requires dependency"
     });
   }
-});
-var packageManifestSchema = z6.union([packageManifestV1Schema, packageManifestV2Schema]);
+}
+var packageManifestV2Schema = z6.object({
+  schemaVersion: z6.literal(2),
+  ...packageManifestModernShape
+}).superRefine(requireProvidesOrDependencies);
+var packageManifestV3Schema = z6.object({
+  schemaVersion: z6.literal(CURRENT_OPENPACK_SCHEMA_VERSION),
+  ...packageManifestModernShape,
+  compositionRules: z6.array(packageCompositionRuleSchema).optional()
+}).superRefine(requireProvidesOrDependencies);
+var packageManifestSchema = z6.union([packageManifestV1Schema, packageManifestV2Schema, packageManifestV3Schema]);
 var openPackManifestNames = ["openpack.json", "openpack.jsonc"];
 var legacyPackageManifestNames = ["agentwheel.json", "agentwheel.jsonc"];
 var packageManifestNames = [...openPackManifestNames, ...legacyPackageManifestNames];
@@ -5741,9 +5765,30 @@ function parsePackageManifest(parsed, path = "package manifest") {
     return parseWithSchema(packageManifestV1Schema, parsed, path);
   }
   if (parsed.schemaVersion === 2) {
+    const violations = v2OpenPackViolations(parsed);
+    if (violations.length > 0) {
+      throw new Error(`OpenPack schemaVersion 3 is required for ${violations.join(", ")} in ${path}. Set "schemaVersion": 3.`);
+    }
     return parseWithSchema(packageManifestV2Schema, parsed, path);
   }
-  throw new Error(`Invalid package manifest ${path}: schemaVersion must be 1 or 2`);
+  if (parsed.schemaVersion === 3) {
+    return parseWithSchema(packageManifestV3Schema, parsed, path);
+  }
+  throw new Error(`Invalid package manifest ${path}: schemaVersion must be 1, 2, or 3`);
+}
+function v2OpenPackViolations(manifest) {
+  const violations = [];
+  if (Object.prototype.hasOwnProperty.call(manifest, "compositionRules")) violations.push("compositionRules");
+  const provides = Array.isArray(manifest.provides) ? manifest.provides : [];
+  for (const [provideIndex, provide] of provides.entries()) {
+    if (!isRecord7(provide) || !isRecord7(provide.items)) continue;
+    for (const [itemName, item] of Object.entries(provide.items)) {
+      if (isRecord7(item) && Object.prototype.hasOwnProperty.call(item, "supersedes")) {
+        violations.push(`provides[${provideIndex}].items.${itemName}.supersedes`);
+      }
+    }
+  }
+  return violations;
 }
 function parseWithSchema(schema, parsed, path) {
   const result = schema.safeParse(parsed);
@@ -5753,7 +5798,7 @@ function parseWithSchema(schema, parsed, path) {
 }
 function v1OpenPackViolations(manifest) {
   const violations = [];
-  for (const key of ["requires", "items", "compose", "runtimes"]) {
+  for (const key of ["requires", "items", "compose", "runtimes", "compositionRules", "supersedes"]) {
     if (Object.prototype.hasOwnProperty.call(manifest, key)) violations.push(key);
   }
   const provides = Array.isArray(manifest.provides) ? manifest.provides : [];
@@ -6003,6 +6048,7 @@ async function artifactForFile(type, name, sourcePath, relativePath, packageName
     requires: item.requires,
     suggests: item.suggests,
     compose: item.compose,
+    supersedes: item.supersedes,
     runtimes: item.runtimes ?? provideRuntimes(provide) ?? manifestRuntimes(manifest)
   };
 }
@@ -6023,6 +6069,7 @@ async function artifactForDir(type, name, sourcePath, relativePath, packageName,
     requires: item.requires,
     suggests: item.suggests,
     compose: item.compose,
+    supersedes: item.supersedes,
     runtimes: item.runtimes ?? provideRuntimes(provide) ?? manifestRuntimes(manifest)
   };
 }
@@ -6030,13 +6077,13 @@ function itemMetadata(provide, itemName) {
   if (!provide || !("items" in provide) || !provide.items || !itemName) return {};
   const item = provide.items[itemName];
   if (!item) return {};
-  return { format: item.format, requires: item.requires, suggests: item.suggests, compose: item.compose, runtimes: item.runtimes };
+  return { format: item.format, requires: item.requires, suggests: item.suggests, compose: item.compose, supersedes: item.supersedes, runtimes: item.runtimes };
 }
 function provideRuntimes(provide) {
   return provide && "runtimes" in provide ? provide.runtimes : void 0;
 }
 function manifestRuntimes(manifest) {
-  return manifest && manifest.schemaVersion === 2 ? manifest.runtimes : void 0;
+  return manifest && manifest.schemaVersion !== 1 ? manifest.runtimes : void 0;
 }
 
 // src/source/clawhub.ts
@@ -7229,7 +7276,14 @@ async function expandMarkdownIncludes(artifacts, packageRoot, options = {}) {
     if (files.length === 0) continue;
     const composedFrom = [];
     for (const file of files) {
-      const result = await expandFile(file, packageRoot, composeEntriesForFile(artifact, file), artifactPaths, options);
+      const localEntries = composeEntriesForFile(artifact, file).map((entry) => ({
+        entry,
+        packageRoot,
+        artifactPaths,
+        nodeId: options.nodeId
+      }));
+      const externalEntries = isPrimaryMarkdownFile(artifact, file) ? options.additionalComposeEntries?.(artifact) ?? [] : [];
+      const result = await expandFile(file, packageRoot, [...localEntries, ...externalEntries], artifactPaths, options);
       if (result.changed) await writeFile17(file, result.content, "utf8");
       composedFrom.push(...result.composedFrom);
     }
@@ -7247,7 +7301,8 @@ async function validateMarkdownIncludes(artifacts, packageRoot, options = {}) {
   const artifactPaths = artifactPathMap(artifacts);
   for (const artifact of artifacts) {
     for (const file of await markdownFilesForArtifact(artifact)) {
-      await expandFile(file, packageRoot, composeEntriesForFile(artifact, file), artifactPaths, options);
+      const entries = composeEntriesForFile(artifact, file).map((entry) => ({ entry, packageRoot, artifactPaths, nodeId: options.nodeId }));
+      await expandFile(file, packageRoot, entries, artifactPaths, options);
     }
   }
 }
@@ -7257,9 +7312,11 @@ async function expandFile(file, packageRoot, appendEntries, artifactPaths, optio
   const expanded = await expandContent(raw, packageRoot, [owner], artifactPaths, options);
   let content = expanded.content;
   const composedFrom = [...expanded.composedFrom];
-  for (const entry of appendEntries) {
-    const included = await expandInclude(entry.include, packageRoot, artifactPaths, {
+  for (const external of appendEntries) {
+    const { entry } = external;
+    const included = await expandInclude(entry.include, external.packageRoot, external.artifactPaths, {
       ...options,
+      nodeId: external.nodeId,
       optional: entry.optional === true,
       markers: entry.markers !== false,
       chain: [owner]
@@ -7437,6 +7494,10 @@ function composeEntriesForFile(artifact, file) {
   if (artifact.kind === "file") return [resolve11(artifact.stagedPath ?? artifact.sourcePath), resolve11(file)].every(Boolean) && resolve11(artifact.stagedPath ?? artifact.sourcePath) === resolve11(file) ? artifact.compose : [];
   return basename16(file) === "SKILL.md" && dirname21(file) === resolve11(artifact.stagedPath ?? artifact.sourcePath) ? artifact.compose : [];
 }
+function isPrimaryMarkdownFile(artifact, file) {
+  if (artifact.kind === "file") return resolve11(artifact.stagedPath ?? artifact.sourcePath) === resolve11(file);
+  return basename16(file) === "SKILL.md" && dirname21(file) === resolve11(artifact.stagedPath ?? artifact.sourcePath);
+}
 function orderedForExpansion(artifacts) {
   return [...artifacts].sort((a, b) => Number(a.type === "fragments") - Number(b.type === "fragments"));
 }
@@ -8923,7 +8984,7 @@ Dependency chain: ${requirement.chain.join(" -> ")}`);
   }
 }
 async function collectDependencyNeeds(state, fetched, options, chain) {
-  if (fetched.manifest?.schemaVersion !== 2) return [];
+  if (!fetched.manifest || fetched.manifest.schemaVersion === 1) return [];
   const dependencies = fetched.manifest.requires ?? {};
   const suggestions = fetched.manifest.suggests ?? {};
   const dependencyEntries = Object.entries(dependencies).sort(([a], [b]) => a.localeCompare(b));
@@ -9487,6 +9548,14 @@ function detectDirectCollisions(nodes) {
   for (const [selector, owners] of bySelector) {
     const uniqueOwners = [...new Map(owners.map((owner) => [owner.node.id, owner])).values()];
     if (uniqueOwners.length <= 1) continue;
+    const replacements = uniqueOwners.filter((owner) => {
+      const artifact = owner.artifacts.find((candidate) => artifactSelectorKey(candidate) === selector);
+      return uniqueOwners.every((other) => {
+        if (other === owner) return true;
+        return artifact?.supersedes?.some((entry) => entry.package === other.node.name && entry.selector === selector) === true;
+      });
+    });
+    if (replacements.length === 1) continue;
     throw new Error(
       `Direct dependency artifact collision for ${selector}: ${uniqueOwners.map((owner) => `${owner.node.id} required by ${owner.node.requiredBy.join(", ")}`).join("; ")}. Resolve by aliasing, deselecting one artifact, or overriding the dependency selection.`
     );
@@ -9806,7 +9875,8 @@ async function renderGraphForTarget(graph, targetContext = {}) {
   const includeEdges = /* @__PURE__ */ new Map();
   const ambiguousPackageNames = ambiguousGraphPackageNames(graph);
   for (const rawNode of graph.rawNodes) {
-    if (rawNode.node.selected.length === 0) continue;
+    const ownsCompositionRules = rawNode.depth === 0 && rawNode.manifest?.schemaVersion === 3 && Boolean(rawNode.manifest.compositionRules?.length);
+    if (rawNode.node.selected.length === 0 && !ownsCompositionRules) continue;
     const rawBundle = await stageResolvedArtifactsRaw(rawNode.resolved, rawNode.artifacts);
     const fragmentCustomized = targetContext.workspaceRoot && targetContext.adapter ? await applyFragmentCustomizations(rawBundle.artifacts, {
       workspaceRoot: targetContext.workspaceRoot,
@@ -9826,11 +9896,18 @@ async function renderGraphForTarget(graph, targetContext = {}) {
     });
   }
   const aliasEdges = aliasEdgeMap(graph);
+  const compositionRules = collectCompositionRules(stagedNodes);
   for (const staged of [...stagedNodes.values()].sort((a, b) => a.rawNode.node.id.localeCompare(b.rawNode.node.id))) {
     const rawNode = staged.rawNode;
     const expandedArtifacts = await expandMarkdownIncludes(staged.artifacts, staged.root, {
       nodeId: rawNode.node.id,
       originNodeId: rawNode.node.id,
+      additionalComposeEntries: (artifact) => matchingCompositionEntries(
+        artifact,
+        rawNode.node.id,
+        targetContext.adapter?.name,
+        compositionRules
+      ),
       resolveCrossPackageInclude: async (request) => {
         const edge = aliasEdges.get(`${request.fromNodeId}\0${request.alias}`);
         if (!edge) {
@@ -9908,6 +9985,50 @@ async function renderGraphForTarget(graph, targetContext = {}) {
     graphLock: createGraphLock(graph, sortedArtifacts.map(lockArtifactFor), targetContext.targetFingerprint, [...includeEdges.values()], namespacing, overrides)
   };
 }
+function collectCompositionRules(stagedNodes) {
+  const rules = [];
+  for (const staged of stagedNodes.values()) {
+    if (staged.rawNode.depth !== 0) continue;
+    const manifest = staged.rawNode.manifest;
+    if (!manifest || manifest.schemaVersion !== 3) continue;
+    for (const rule of manifest.compositionRules ?? []) {
+      rules.push({
+        ownerNodeId: staged.rawNode.node.id,
+        ownerPackageName: staged.rawNode.node.name,
+        rule,
+        packageRoot: staged.root,
+        artifactPaths: staged.artifactPaths
+      });
+    }
+  }
+  return rules.sort((a, b) => `${a.ownerNodeId}\0${a.rule.target}\0${a.rule.include}`.localeCompare(`${b.ownerNodeId}\0${b.rule.target}\0${b.rule.include}`));
+}
+function matchingCompositionEntries(artifact, targetNodeId, runtime, rules) {
+  const selector = `${artifact.type}/${artifact.name}`;
+  const qualifiedSelector = `${artifact.packageName ?? targetNodeId}:${selector}`;
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const candidate of rules) {
+    const { rule } = candidate;
+    if (rule.runtimes?.length && (!runtime || !rule.runtimes.includes(runtime))) continue;
+    if (!globMatches(rule.target, selector) && !globMatches(rule.target, qualifiedSelector)) continue;
+    if (rule.exclude?.some((pattern) => globMatches(pattern, selector) || globMatches(pattern, qualifiedSelector))) continue;
+    const key = `${candidate.ownerNodeId}\0${rule.include}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    entries.push({
+      entry: { include: rule.include, markers: rule.markers },
+      packageRoot: candidate.packageRoot,
+      artifactPaths: candidate.artifactPaths,
+      nodeId: candidate.ownerNodeId
+    });
+  }
+  return entries;
+}
+function globMatches(pattern, value) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
 function aliasEdgeMap(graph) {
   return new Map(graph.edges.map((edge) => [`${edge.from}\0${edge.alias}`, { to: edge.to }]));
 }
@@ -9939,10 +10060,12 @@ function sha2563(content) {
   return createHash10("sha256").update(content).digest("hex");
 }
 function assignInstallNames(graph, artifacts) {
+  const superseded = supersededLogicalSelectors(artifacts);
+  const effectiveArtifacts = artifacts.filter((artifact) => !superseded.has(artifact.logicalSelector));
   const aliases = workspaceAliases(graph);
-  validateAliasScopes(graph, artifacts, aliases);
+  validateAliasScopes(graph, effectiveArtifacts, aliases);
   const decisions = /* @__PURE__ */ new Map();
-  const withAliases = artifacts.map((artifact) => {
+  const withAliases = effectiveArtifacts.map((artifact) => {
     const alias = aliasForArtifact(artifact, graph, aliases);
     if (!alias) return artifact;
     const updated = { ...artifact, installName: alias };
@@ -9981,6 +10104,23 @@ function assignInstallNames(graph, artifacts) {
   }));
   return { artifacts: out, namespacing: [...decisions.values()], overrides: finalOverrides };
 }
+function supersededLogicalSelectors(artifacts) {
+  const removed = /* @__PURE__ */ new Set();
+  for (const replacement of artifacts) {
+    for (const declaration of replacement.supersedes ?? []) {
+      const replacementSelector = `${replacement.type}/${replacement.name}`;
+      if (declaration.selector !== replacementSelector) {
+        throw new Error(`Supersedes selector must match the replacement artifact ${replacement.logicalSelector}: ${declaration.selector}`);
+      }
+      const matches = artifacts.filter((candidate) => candidate !== replacement && candidate.packageName === declaration.package && `${candidate.type}/${candidate.name}` === declaration.selector);
+      if (matches.length > 1) {
+        throw new Error(`Supersedes target is ambiguous for ${replacement.logicalSelector}: ${declaration.package}:${declaration.selector}`);
+      }
+      if (matches[0]) removed.add(matches[0].logicalSelector);
+    }
+  }
+  return removed;
+}
 function applyWorkspaceOverrides(graph, artifacts) {
   const directives = workspaceOverrides(graph);
   if (directives.length === 0) return { artifacts, overrides: [] };
@@ -10180,7 +10320,8 @@ function lockArtifactFor(artifact) {
     kind: artifact.kind,
     hash: artifact.hash,
     channel: artifact.channel ?? "managed",
-    composedFrom: artifact.composedFrom
+    composedFrom: artifact.composedFrom,
+    supersedes: artifact.supersedes
   };
 }
 
@@ -11336,15 +11477,25 @@ async function validatePackage(root) {
   } catch (error) {
     findings.push({ level: "error", message: error instanceof Error ? error.message : String(error), path: packageRoot });
   }
-  if (manifest.schemaVersion === 2 && manifest.compose) {
+  if (manifest.schemaVersion !== 1 && manifest.compose) {
     for (const entry of manifest.compose) {
       await validateManifestComposeInclude(packageRoot, entry.include, entry.optional === true, findings, manifestPath, Object.keys(manifest.requires ?? {}));
     }
   }
+  if (manifest.schemaVersion === 3) {
+    const aliases = Object.keys(manifest.requires ?? {});
+    for (const [index, rule] of (manifest.compositionRules ?? []).entries()) {
+      validateSelector(rule.include, `compositionRules[${index}].include`, findings, manifestPath, { fragmentsOnly: true, aliases });
+      if (!rule.target.startsWith("skills/")) {
+        findings.push({ level: "error", message: `compositionRules[${index}].target: v3 composition rules may target only skills/*`, path: manifestPath });
+      }
+      await validateManifestComposeInclude(packageRoot, rule.include, false, findings, manifestPath, aliases);
+    }
+  }
   return { ok: !findings.some((finding) => finding.level === "error"), manifestPath, findings };
 }
 function validateDeclaredSelectors(manifest, findings, manifestPath) {
-  if (manifest.schemaVersion === 2) {
+  if (manifest.schemaVersion !== 1) {
     for (const [alias, dependency] of Object.entries(manifest.requires ?? {})) {
       if (!alias.trim()) {
         findings.push({ level: "error", message: "Dependency alias must be non-empty", path: manifestPath });
@@ -11365,13 +11516,19 @@ function validateDeclaredSelectors(manifest, findings, manifestPath) {
   for (const [provideIndex, provide] of manifest.provides.entries()) {
     if (!("items" in provide) || !provide.items) continue;
     for (const [itemName, item] of Object.entries(provide.items)) {
+      for (const declaration of item.supersedes ?? []) {
+        const expected = `${provide.type}/${itemName}`;
+        if (declaration.selector !== expected) {
+          findings.push({ level: "error", message: `provides[${provideIndex}].items.${itemName}.supersedes: selector must equal ${expected}`, path: manifestPath });
+        }
+      }
       for (const requirement of item.requires ?? []) {
         const selector = typeof requirement === "string" ? requirement : requirement.selector;
-        validateSelector(selector, `provides[${provideIndex}].items.${itemName}.requires`, findings, manifestPath, { aliases: manifest.schemaVersion === 2 ? Object.keys(manifest.requires ?? {}) : [] });
+        validateSelector(selector, `provides[${provideIndex}].items.${itemName}.requires`, findings, manifestPath, { aliases: manifest.schemaVersion !== 1 ? Object.keys(manifest.requires ?? {}) : [] });
       }
       for (const suggestion of item.suggests ?? []) {
         const alias = typeof suggestion === "string" ? suggestion : suggestion.alias;
-        if (manifest.schemaVersion === 2 && !Object.keys(manifest.suggests ?? {}).includes(alias)) {
+        if (manifest.schemaVersion !== 1 && !Object.keys(manifest.suggests ?? {}).includes(alias)) {
           findings.push({ level: "error", message: `provides[${provideIndex}].items.${itemName}.suggests: suggestion alias not declared: ${alias}`, path: manifestPath });
         }
         for (const selector of typeof suggestion === "string" ? [] : suggestion.select ?? []) {
@@ -11380,7 +11537,7 @@ function validateDeclaredSelectors(manifest, findings, manifestPath) {
       }
       for (const entry of item.compose ?? []) {
         validateSelector(entry.include, `provides[${provideIndex}].items.${itemName}.compose.include`, findings, manifestPath, {
-          aliases: manifest.schemaVersion === 2 ? Object.keys(manifest.requires ?? {}) : [],
+          aliases: manifest.schemaVersion !== 1 ? Object.keys(manifest.requires ?? {}) : [],
           fragmentsOnly: true
         });
       }

package/openpack.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "name": "NestDevLab/agentwheel",
-  "version": "0.18.5",
+  "version": "0.19.0",
   "provides": [
     { "type": "skills", "path": "skills" }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.18.5",
+  "version": "0.19.0",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",

package/skills/agentwheel/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.18.5"
+  version: "0.19.0"
 ---
 
 # agentwheel

package/skills/agentwheel-discovery/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.18.5"
+  version: "0.19.0"
 ---
 
 # Agentwheel Discovery