@agentxm/extension-model 0.37.0 → 0.38.0

package/dist/src/unstable/agent-capabilities/schema.js

@@ -225,6 +225,7 @@ export const PluginDescriptorSchema = Schema.Struct({
 /** @experimental This API is unstable and may change without notice. */
 const NativeAvailabilitySchema = Schema.Struct({ via: Schema.Literal("native") });
 const NoneAvailabilitySchema = Schema.Struct({ via: Schema.Literal("none") });
+const UnknownAvailabilitySchema = Schema.Struct({ via: Schema.Literal("unknown") });
 const PluginAvailabilitySchema = Schema.Struct({
     via: Schema.Literal("plugin"),
     provider: Schema.Literals(["first-party", "third-party"]),
@@ -238,11 +239,12 @@ const AvailableCapabilityAvailabilitySchema = Schema.Union([
 export const AvailabilitySchema = Schema.Union([
     NativeAvailabilitySchema,
     NoneAvailabilitySchema,
+    UnknownAvailabilitySchema,
     PluginAvailabilitySchema,
 ]).annotate({
     identifier: "Availability",
     title: "Availability",
-    description: "Whether the agent capability surface is obtainable natively, via plugin, or not.",
+    description: "Whether a surface is native, plugin-backed, documented absent, or not established.",
 });
 const VendorStatusSinceSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.isPattern(ISO_DATE_PATTERN, {
     message: "Expected an ISO 8601 date in YYYY-MM-DD form.",
@@ -267,6 +269,9 @@ export const VendorStatusSchema = Schema.Union([
 export const AgentInterfaceSchema = Schema.Literals([
     "cli",
     "ide-extension",
+    "desktop",
+    "embedded",
+    "workspace-agent",
     "chat",
     "hosted-agent",
 ]).annotate({
@@ -357,6 +362,52 @@ export const LastVerifiedDateSchema = Schema.NonEmptyString.pipe(Schema.check(Sc
     description: "Date a capability claim was last verified.",
     examples: ["2026-05-16"],
 });
+/** A source review establishes only the claims within its stated scope. */
+export const CatalogReviewSchema = Schema.Struct({
+    reviewedAt: LastVerifiedDateSchema,
+    sources: Schema.NonEmptyArray(UrlSchema),
+    conditions: Schema.Array(Schema.NonEmptyString),
+    limitations: Schema.Array(Schema.NonEmptyString),
+    claimScope: Schema.optionalKey(Schema.NonEmptyString),
+}).annotate({
+    identifier: "CatalogReview",
+    description: "Documented claim review, independent of AXM or vendor runtime execution.",
+});
+/** Execution evidence is never inferred from documentation or a legacy date. */
+export const AxmVerificationSchema = Schema.Struct({
+    verifiedAt: LastVerifiedDateSchema,
+    boundary: Schema.Literals(["configuration", "vendor-runtime"]),
+    evidence: Schema.NonEmptyArray(Schema.NonEmptyString),
+    limitations: Schema.Array(Schema.NonEmptyString),
+}).annotate({
+    identifier: "AxmVerification",
+    description: "Attributable evidence of AXM configuration output or actual vendor runtime use.",
+});
+export const AgentProfileSchema = Schema.Struct({
+    identity: Schema.Struct({
+        product: Schema.NonEmptyString,
+        surface: Schema.NonEmptyString,
+        edition: Schema.NullOr(Schema.NonEmptyString),
+        ownership: Schema.NullOr(Schema.Struct({
+            company: Schema.NonEmptyString,
+            parentCompany: Schema.NullOr(Schema.NonEmptyString),
+            sources: Schema.NonEmptyArray(UrlSchema),
+        })),
+        modelProviders: Schema.NullOr(Schema.Array(Schema.NonEmptyString)),
+    }),
+    review: CatalogReviewSchema,
+    lifecycleQualifications: Schema.Array(Schema.Struct({
+        scope: Schema.Literals(["vendor", "product", "surface", "edition"]),
+        subject: Schema.NonEmptyString,
+        state: Schema.Literals(["active", "maintenance", "deprecated", "retired"]),
+        since: Schema.NullOr(LastVerifiedDateSchema),
+        note: Schema.NonEmptyString,
+        sources: Schema.NonEmptyArray(UrlSchema),
+    })),
+}).annotate({
+    identifier: "AgentProfile",
+    description: "Scoped product identity and research; it does not certify every capability.",
+});
 const CapabilityNotesSchema = Schema.NullOr(Schema.NonEmptyString);
 const CapabilityDocsSchema = Schema.Array(DocLinkSchema);
 const CapabilitySourcesSchema = Schema.Array(UrlSchema);
@@ -373,11 +424,12 @@ export const ProvenanceSchema = Schema.Struct(NullableProvenanceFields).annotate
     description: "Source URLs and verification date for a catalog capability claim.",
 });
 const UnavailableNativeCapabilityFields = {
-    availability: NoneAvailabilitySchema,
+    availability: Schema.Union([NoneAvailabilitySchema, UnknownAvailabilitySchema]),
     vendorStatus: VendorStatusSchema,
     notes: CapabilityNotesSchema,
     docs: CapabilityDocsSchema,
     sources: CapabilitySourcesSchema,
+    review: Schema.optionalKey(CatalogReviewSchema),
 };
 const AvailableNativeCapabilityBaseFields = {
     availability: AvailableCapabilityAvailabilitySchema,
@@ -385,6 +437,7 @@ const AvailableNativeCapabilityBaseFields = {
     notes: CapabilityNotesSchema,
     docs: CapabilityDocsSchema,
     sources: CapabilitySourcesSchema,
+    review: Schema.optionalKey(CatalogReviewSchema),
     scopes: NonEmptyScopesSchema,
 };
 const SpecTrackedCapabilityFields = {
@@ -395,10 +448,11 @@ const AvailableSpecTrackedNativeCapabilityFields = {
     ...AvailableNativeCapabilityBaseFields,
     ...SpecTrackedCapabilityFields,
 };
-const axmCapabilityStateDescription = "AXM integration state for this capability: AXM support status, AXM verification date, optional writer metadata, and AXM-owned rationale. This is not a vendor fact.";
+const axmCapabilityStateDescription = "AXM integration state. lastVerified is a legacy record date with no recorded method; only verification carries attributable execution evidence. Neither is a vendor research review.";
 const axmCapabilityStateSchema = (writerSchema, identifier) => Schema.Struct({
     status: AxmSupportSchema,
     lastVerified: Schema.NullOr(LastVerifiedDateSchema),
+    verification: Schema.optionalKey(Schema.NullOr(AxmVerificationSchema)),
     reason: Schema.optionalKey(Schema.NonEmptyString),
     writer: Schema.NullOr(writerSchema),
 }).annotate({
@@ -460,6 +514,13 @@ export const SubagentsExtensionCapabilitySchema = Schema.Struct({
             availability: NativeAvailabilitySchema,
             locations: Schema.Array(NativeReadLocationSchema),
         }),
+        Schema.Struct({
+            ...AvailableNativeCapabilityBaseFields,
+            availability: NativeAvailabilitySchema,
+            modeling: Schema.Literal("native-unmodeled"),
+            scopes: Schema.Array(ScopeSchema),
+            locations: Schema.Array(Schema.Never),
+        }),
         PluginSubagentsNativeCapabilitySchema,
         Schema.Struct(UnavailableNativeCapabilityFields),
     ]),
@@ -535,7 +596,7 @@ export const NativeConfigReadLocationSchema = Schema.Struct({
     shape: Schema.Literal("file"),
     id: Schema.NonEmptyString,
     format: ConfigFileFormatSchema,
-    keyPath: Schema.optionalKey(Schema.NonEmptyArray(Schema.NonEmptyString)),
+    keyPath: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
     attribution: Schema.optionalKey(Schema.Literals(["shared", "agent"])),
     gitignored: Schema.optionalKey(Schema.Boolean),
 })
@@ -561,17 +622,11 @@ const nativeConfigReferenceIssues = (locations, references, writerPath) => {
     return issues;
 };
 /** @experimental This API is unstable and may change without notice. */
-export const McpServersKeySchema = Schema.Literals([
-    "mcpServers",
-    "servers",
-    "mcp",
-    "mcp_servers",
-    "context_servers",
-]).annotate({
-    identifier: "McpServersKey",
-    title: "MCP Servers Key",
-    description: "Top-level key containing MCP server entries in an agent config file.",
-    examples: ["mcpServers", "servers", "mcp"],
+export const McpServersPathSchema = Schema.NonEmptyArray(Schema.NonEmptyString).annotate({
+    identifier: "McpServersPath",
+    title: "MCP Servers Path",
+    description: "Object key path containing MCP server entries in a native config file.",
+    examples: [["mcpServers"], ["mcp", "servers"]],
 });
 /** @experimental This API is unstable and may change without notice. */
 export const McpTargetAttributionSchema = Schema.Literals(["shared", "agent"]).annotate({
@@ -694,7 +749,7 @@ export const McpConfigSchema = Schema.Struct({
 });
 /** @experimental This API is unstable and may change without notice. */
 export const McpEnvExpansionSchema = Schema.Struct({
-    variables: Schema.Literals(["none", "braced"]),
+    variables: Schema.Literals(["none", "braced", "env-tag"]),
     defaults: Schema.Boolean,
 }).annotate({
     identifier: "McpEnvExpansion",
@@ -716,8 +771,19 @@ const McpAvailableCapabilityStruct = Schema.Struct({
     native: McpNativeWithTransportsSchema,
     axm: axmCapabilityStateSchema(Schema.Struct({ config: McpConfigSchema }), "McpAxmState"),
 });
+const McpUnmodeledCapabilityStruct = Schema.Struct({
+    native: Schema.Struct({
+        ...AvailableNativeCapabilityBaseFields,
+        modeling: Schema.Literal("native-unmodeled"),
+        scopes: Schema.Array(ScopeSchema),
+        locations: Schema.Array(Schema.Never),
+        entryDialect: Schema.Null,
+    }),
+    axm: NoWriterAxmCapabilityStateSchema,
+});
 const McpExtensionCapabilityStruct = Schema.Union([
     McpAvailableCapabilityStruct,
+    McpUnmodeledCapabilityStruct,
     McpUnavailableCapabilityStruct,
 ]);
 const McpExtensionCapabilitySchemaWithChecks = McpExtensionCapabilityStruct.pipe(Schema.check(Schema.makeFilter((capability) => {
@@ -739,12 +805,10 @@ const McpExtensionCapabilitySchemaWithChecks = McpExtensionCapabilityStruct.pipe
                 issue: "MCP reader locations require explicit attribution.",
             });
         const selected = new Set(writer?.config.locationIds ?? []);
-        if (capability.native.locations.some((location) => selected.has(location.id) &&
-            (location.keyPath?.length !== 1 ||
-                !Schema.is(McpServersKeySchema)(location.keyPath[0])))) {
+        if (capability.native.locations.some((location) => selected.has(location.id) && !Schema.is(McpServersPathSchema)(location.keyPath))) {
             issues.push({
                 path: ["native", "locations"],
-                issue: "Writable MCP locations require one recognized MCP servers key.",
+                issue: "Writable MCP locations require a nonempty servers-container key path.",
             });
         }
     }
@@ -874,7 +938,14 @@ export const HookToolMappingSchema = Schema.Struct({
     description: "Native tool name with its canonical AXM tool identity and provenance.",
 });
 /** @experimental This API is unstable and may change without notice. */
-export const HookMechanismFamilySchema = Schema.Literals(["command-stdin", "raw"]).annotate({
+export const HookMechanismFamilySchema = Schema.Literals([
+    "command-stdin",
+    "http",
+    "prompt",
+    "agent",
+    "mcp",
+    "raw",
+]).annotate({
     identifier: "HookMechanismFamily",
     title: "Hook Mechanism Family",
     description: "How a native hook system invokes a hook.",
@@ -1014,6 +1085,7 @@ const HooksAvailableNativeCapabilitySchema = Schema.Struct({
 });
 const HooksUnmodeledNativeCapabilitySchema = Schema.Struct({
     ...AvailableNativeCapabilityBaseFields,
+    scopes: Schema.Array(ScopeSchema),
     modeling: Schema.Literal("native-unmodeled"),
     entryDialect: Schema.NullOr(HookEntryDialectSchema),
     locations: Schema.Array(NativeConfigReadLocationSchema),
@@ -1032,10 +1104,10 @@ export const HooksExtensionCapabilitySchema = HooksExtensionCapabilityStruct.pip
     if ("locations" in capability.native) {
         issues.push(...nativeConfigReferenceIssues(capability.native.locations, capability.axm.writer?.locationIds ?? [], ["axm", "writer", "locationIds"]));
         const selected = new Set(capability.axm.writer?.locationIds ?? []);
-        if (capability.native.locations.some((location) => selected.has(location.id) && location.keyPath === undefined))
+        if (capability.native.locations.some((location) => selected.has(location.id) && location.keyPath?.length !== 1))
             issues.push({
                 path: ["native", "locations"],
-                issue: "Writable Hook reader locations require a static keyPath.",
+                issue: "Writable Hook reader locations require a single static container key.",
             });
     }
     if (capability.axm.writer !== null &&
@@ -1243,6 +1315,7 @@ const AgentStruct = Schema.Struct({
     rootDir: Schema.NullOr(Schema.NonEmptyString),
     installTarget: Schema.optionalKey(HostedInstallTargetSchema),
     lifecycle: AgentLifecycleSchema,
+    profile: Schema.optionalKey(AgentProfileSchema),
     detection: DetectionSchema,
     docs: Schema.Array(DocLinkSchema),
     capabilities: AgentCapabilitiesSchema,

package/dist/src/unstable/agent-capabilities/verification.d.ts

@@ -1,23 +1,39 @@
-import type { Agent, AgentExtensionCapability } from "./schema.js";
+import * as Schema from "effect/Schema";
+import { type Agent } from "./schema.js";
 /** @experimental This API is unstable and may change without notice. */
 export declare const CAPABILITY_VERIFICATION_BUDGET_DAYS: {
     readonly skill: 90;
+    readonly "mcp-server": 90;
+    readonly subagent: 90;
+    readonly hook: 90;
+    readonly rule: 90;
+    readonly permissions: 90;
 };
 /** @experimental This API is unstable and may change without notice. */
 export type AgentCapabilitySlot = keyof Agent["capabilities"] | "rule" | "permissions";
 /** @experimental This API is unstable and may change without notice. */
-export interface CapabilityVerificationAge {
-    readonly agentId: string;
-    readonly capability: AgentCapabilitySlot;
-    readonly status: AgentExtensionCapability["axm"]["status"];
-    readonly lastVerified: string | null;
-    readonly ageDays: number | null;
-    readonly budgetDays: number | null;
-    readonly overdue: boolean;
-}
+export declare const CapabilityVerificationAgeSchema: Schema.Struct<{
+    readonly agentId: Schema.String;
+    readonly capability: Schema.Literals<readonly ["skill", "mcp-server", "subagent", "hook", "rule", "permissions"]>;
+    readonly status: Schema.Literals<readonly ["supported", "planned", "unsupported", "unknown"]>;
+    readonly legacyLastVerified: Schema.NullOr<Schema.NonEmptyString>;
+    readonly legacyAgeDays: Schema.NullOr<Schema.Number>;
+    readonly reviewedAt: Schema.NullOr<Schema.NonEmptyString>;
+    readonly reviewAgeDays: Schema.NullOr<Schema.Number>;
+    readonly reviewMissing: Schema.Boolean;
+    readonly verifiedAt: Schema.NullOr<Schema.NonEmptyString>;
+    readonly verificationAgeDays: Schema.NullOr<Schema.Number>;
+    readonly verificationMissing: Schema.Boolean;
+    readonly verificationBoundary: Schema.NullOr<Schema.Literals<readonly ["configuration", "vendor-runtime"]>>;
+    readonly budgetDays: Schema.Number;
+    readonly reviewOverdue: Schema.Boolean;
+    readonly verificationOverdue: Schema.Boolean;
+}>;
+export type CapabilityVerificationAge = Schema.Schema.Type<typeof CapabilityVerificationAgeSchema>;
 /**
- * Reports verification age for every catalog capability independently. Pass an
- * ISO date explicitly so CI and maintenance tooling produce reproducible output.
+ * Reports source review, execution verification and historical record age
+ * independently. Missing evidence stays missing, even after a profile review.
+ * Pass an ISO date explicitly so maintenance tooling is reproducible.
  *
  * @experimental This API is unstable and may change without notice.
  */

package/dist/src/unstable/agent-capabilities/verification.js

@@ -1,7 +1,32 @@
+import * as Schema from "effect/Schema";
+import { AxmSupportSchema, LastVerifiedDateSchema, } from "./schema.js";
 /** @experimental This API is unstable and may change without notice. */
 export const CAPABILITY_VERIFICATION_BUDGET_DAYS = {
     skill: 90,
+    "mcp-server": 90,
+    subagent: 90,
+    hook: 90,
+    rule: 90,
+    permissions: 90,
 };
+/** @experimental This API is unstable and may change without notice. */
+export const CapabilityVerificationAgeSchema = Schema.Struct({
+    agentId: Schema.String,
+    capability: Schema.Literals(["skill", "mcp-server", "subagent", "hook", "rule", "permissions"]),
+    status: AxmSupportSchema,
+    legacyLastVerified: Schema.NullOr(LastVerifiedDateSchema),
+    legacyAgeDays: Schema.NullOr(Schema.Number),
+    reviewedAt: Schema.NullOr(LastVerifiedDateSchema),
+    reviewAgeDays: Schema.NullOr(Schema.Number),
+    reviewMissing: Schema.Boolean,
+    verifiedAt: Schema.NullOr(LastVerifiedDateSchema),
+    verificationAgeDays: Schema.NullOr(Schema.Number),
+    verificationMissing: Schema.Boolean,
+    verificationBoundary: Schema.NullOr(Schema.Literals(["configuration", "vendor-runtime"])),
+    budgetDays: Schema.Number,
+    reviewOverdue: Schema.Boolean,
+    verificationOverdue: Schema.Boolean,
+});
 const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1_000;
 const capabilitySlots = (agent) => [
     ["skill", agent.capabilities.skill],
@@ -17,24 +42,36 @@ const ageInDays = (lastVerified, asOf) => {
     return Math.floor((reportAt - verifiedAt) / DAY_IN_MILLISECONDS);
 };
 /**
- * Reports verification age for every catalog capability independently. Pass an
- * ISO date explicitly so CI and maintenance tooling produce reproducible output.
+ * Reports source review, execution verification and historical record age
+ * independently. Missing evidence stays missing, even after a profile review.
+ * Pass an ISO date explicitly so maintenance tooling is reproducible.
  *
  * @experimental This API is unstable and may change without notice.
  */
 export const capabilityVerificationAgeReport = (agents, asOf) => agents.flatMap((agent) => capabilitySlots(agent).map(([capabilityName, capability]) => {
-    const budgetDays = capabilityName === "skill" ? CAPABILITY_VERIFICATION_BUDGET_DAYS.skill : null;
-    const ageDays = capability.axm.lastVerified === null ? null : ageInDays(capability.axm.lastVerified, asOf);
+    const budgetDays = CAPABILITY_VERIFICATION_BUDGET_DAYS[capabilityName];
+    const legacyAgeDays = capability.axm.lastVerified === null ? null : ageInDays(capability.axm.lastVerified, asOf);
+    const reviewedAt = capability.native.review?.reviewedAt ?? null;
+    const verifiedAt = capability.axm.verification?.verifiedAt ?? null;
+    const reviewAgeDays = reviewedAt === null ? null : ageInDays(reviewedAt, asOf);
+    const verificationAgeDays = verifiedAt === null ? null : ageInDays(verifiedAt, asOf);
     return {
         agentId: agent.id,
         capability: capabilityName,
         status: capability.axm.status,
-        lastVerified: capability.axm.lastVerified,
-        ageDays,
+        legacyLastVerified: capability.axm.lastVerified,
+        legacyAgeDays,
+        reviewedAt,
+        reviewAgeDays,
+        reviewMissing: reviewedAt === null,
+        verifiedAt,
+        verificationAgeDays,
+        verificationMissing: verifiedAt === null,
+        verificationBoundary: capability.axm.verification?.boundary ?? null,
         budgetDays,
-        overdue: capability.axm.status === "supported" &&
-            budgetDays !== null &&
-            (ageDays === null || ageDays > budgetDays),
+        reviewOverdue: reviewAgeDays === null || reviewAgeDays > budgetDays,
+        verificationOverdue: (capability.axm.status === "supported" || capability.axm.writer !== null) &&
+            (verificationAgeDays === null || verificationAgeDays > budgetDays),
     };
 }));
 //# sourceMappingURL=verification.js.map

package/dist/src/unstable/agents/types.d.ts

@@ -59,7 +59,7 @@ export interface AgentDetectionDescriptor {
 /** @experimental This API is unstable and may change without notice. */
 export { CONFIGURABLE_AGENT_IDS, type ConfigurableAgentId };
 /** Real agents that can participate in native materialization. @experimental */
-export declare const MATERIALIZATION_TARGET_IDS: readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"];
+export declare const MATERIALIZATION_TARGET_IDS: readonly ["adal", "fx", "muse-code", "mimo-code", "coder-agents", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"];
 /** @experimental This API is unstable and may change without notice. */
 export type MaterializationTargetId = (typeof MATERIALIZATION_TARGET_IDS)[number];
 /**

package/dist/src/unstable/extensions/common.d.ts

@@ -681,7 +681,7 @@ export { AgentIdSchema };
  *
  * @experimental This API is unstable and may change without notice.
  */
-export declare const ConfigurableAgentIdSchema: Schema.Literals<readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"]>;
+export declare const ConfigurableAgentIdSchema: Schema.Literals<readonly ["adal", "fx", "muse-code", "mimo-code", "coder-agents", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"]>;
 /**
  * Inferred type for AgentId schema.
  *

package/dist/src/unstable/extensions/universal-skills-dir.d.ts

@@ -24,27 +24,6 @@ export declare const UNIVERSAL_SKILLS_DIR_SEGMENT: string;
  * Strips trailing path separators from a path string.
  */
 export declare const stripTrailingSeparators: (path: string) => string;
-/**
- * Returns `true` when `dir` is the workspace-relative universal skills
- * directory path. Use for descriptor-level comparisons where paths are
- * relative (e.g., `agent.skills.dir`).
- *
- * @see {@link isUniversalSkillsDir} for absolute resolved-path comparisons
- * (e.g., after `resolveEffectiveSkillsDir`).
- */
-export declare const isUniversalSkillsRelativeDir: (dir: string) => boolean;
-/**
- * Resolve per-agent artifact presence when some agents share the universal
- * skills directory. If any agent in `universalAgentIds` has the artifact,
- * all agents in that set are treated as having it — because the directory
- * is shared, one symlink/copy satisfies them all.
- *
- * Returns the input unchanged when `universalAgentIds` is empty.
- */
-export declare const resolveUniversalDirPresence: <T extends {
-    readonly agentId: string;
-    readonly exists: boolean;
-}>(perAgent: ReadonlyArray<T>, universalAgentIds: ReadonlySet<string>) => ReadonlyArray<T>;
 /**
  * Returns `true` when `resolvedDir` points to the universal skills directory
  * (`<workspaceRoot>/.agents/skills`).
@@ -52,7 +31,6 @@ export declare const resolveUniversalDirPresence: <T extends {
  * Both paths are normalized by stripping trailing separators before comparison.
  *
  * Intended for comparing resolved absolute paths from `resolveEffectiveSkillsDir`.
- * For descriptor-level relative paths, use {@link isUniversalSkillsRelativeDir}.
  */
 export declare const isUniversalSkillsDir: (resolvedDir: string, workspaceRoot: string) => boolean;
 //# sourceMappingURL=universal-skills-dir.d.ts.map

package/dist/src/unstable/extensions/universal-skills-dir.js

@@ -30,33 +30,6 @@ export const stripTrailingSeparators = (path) => {
     }
     return path.slice(0, end);
 };
-/**
- * Returns `true` when `dir` is the workspace-relative universal skills
- * directory path. Use for descriptor-level comparisons where paths are
- * relative (e.g., `agent.skills.dir`).
- *
- * @see {@link isUniversalSkillsDir} for absolute resolved-path comparisons
- * (e.g., after `resolveEffectiveSkillsDir`).
- */
-export const isUniversalSkillsRelativeDir = (dir) => dir === UNIVERSAL_SKILLS_DIR;
-/**
- * Resolve per-agent artifact presence when some agents share the universal
- * skills directory. If any agent in `universalAgentIds` has the artifact,
- * all agents in that set are treated as having it — because the directory
- * is shared, one symlink/copy satisfies them all.
- *
- * Returns the input unchanged when `universalAgentIds` is empty.
- */
-export const resolveUniversalDirPresence = (perAgent, universalAgentIds) => {
-    if (universalAgentIds.size === 0) {
-        return perAgent;
-    }
-    const anyUniversalExists = perAgent.some((p) => p.exists && universalAgentIds.has(p.agentId));
-    if (!anyUniversalExists) {
-        return perAgent;
-    }
-    return perAgent.map((p) => (universalAgentIds.has(p.agentId) ? { ...p, exists: true } : p));
-};
 /**
  * Returns `true` when `resolvedDir` points to the universal skills directory
  * (`<workspaceRoot>/.agents/skills`).
@@ -64,7 +37,6 @@ export const resolveUniversalDirPresence = (perAgent, universalAgentIds) => {
  * Both paths are normalized by stripping trailing separators before comparison.
  *
  * Intended for comparing resolved absolute paths from `resolveEffectiveSkillsDir`.
- * For descriptor-level relative paths, use {@link isUniversalSkillsRelativeDir}.
  */
 export const isUniversalSkillsDir = (resolvedDir, workspaceRoot) => {
     const sep = "/";

package/package.json

@@ -11,7 +11,7 @@
   },
   "description": "Shared AgentXM extension model: identities, manifests, version constraints, and agent capabilities. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@agentxm/specification-metadata": "0.37.0",
+    "@agentxm/specification-metadata": "0.38.0",
     "@effect/vitest": "4.0.0-rc.117",
     "@fast-check/vitest": "^0.5.0",
     "@types/semver": "^7.8.0",
@@ -305,5 +305,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.37.0"
+  "version": "0.38.0"
 }