@agentxm/extension-model 0.28.4-bootstrap.0

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

@@ -0,0 +1,389 @@
+/**
+ * Pure derivation helpers for the agent capability catalog.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { PER_AGENT_EXTENSION_TYPES } from "../extensions/common.js";
+import { AGENTS, CONFIGURABLE_AGENT_IDS } from "./catalog.js";
+import { LEAF_EXTENSION_TYPES } from "../extension-types/schema.js";
+import { SUPPORTED_AXM_SUPPORT, } from "./schema.js";
+import {} from "../extensions/common.js";
+/** @experimental This API is unstable and may change without notice. */
+export const isLeafExtensionType = (value) => value !== "pack";
+/** @experimental This API is unstable and may change without notice. */
+export const agentCapabilityStatus = (capability) => {
+    switch (capability.native.availability.via) {
+        case "none":
+            return "none";
+        case "native":
+            return capability.native.vendorStatus.state === "active" ? "native" : "native-deprecated";
+        case "plugin":
+            return capability.native.vendorStatus.state === "active" ? "plugin" : "plugin-deprecated";
+    }
+};
+/** @experimental This API is unstable and may change without notice. */
+export const axmIntegrationStatus = (capability) => capability.axm.writer === null ? capability.axm.status : "writer";
+/** @experimental This API is unstable and may change without notice. */
+export const isCapabilitySupported = (capability) => (capability.axm.writer !== null || capability.axm.status === SUPPORTED_AXM_SUPPORT) &&
+    capability.native.availability.via !== "none";
+const perAgentTypes = new Set(PER_AGENT_EXTENSION_TYPES);
+const isPerAgentType = (type) => perAgentTypes.has(type);
+/**
+ * The capability record describing how one agent handles an extension type.
+ * `rule` resolves to the agent's `instructions` slot: rules render into shared
+ * workspace instruction files, but each agent still records how it consumes
+ * them. `knowledge` has no per-agent record because it is read on demand, so
+ * it resolves to `undefined`.
+ */
+const capabilityForType = (agent, type) => {
+    if (type === "rule")
+        return agent.instructions;
+    if (isPerAgentType(type))
+        return agent.capabilities[type];
+    return undefined;
+};
+const configurableAgentIds = new Set(CONFIGURABLE_AGENT_IDS);
+const isConfigurableAgentId = (id) => configurableAgentIds.has(id);
+const deriveAgentId = (agent) => {
+    if (isConfigurableAgentId(agent.id))
+        return agent.id;
+    throw new Error(`Cannot derive filesystem descriptor for non-configurable agent: ${agent.id}`);
+};
+const firstPathSegment = (path) => path.split("/")[0];
+const deriveRootDir = (agent) => agent.rootDir === null
+    ? undefined
+    : agent.rootDir ||
+        ("directory" in agent.capabilities.skill.native
+            ? firstPathSegment(agent.capabilities.skill.native.directory)
+            : undefined);
+/** @experimental This API is unstable and may change without notice. */
+export const deriveSkillConvention = (directory) => directory === ".agents/skills" || directory.startsWith(".agents/skills/")
+    ? "universal"
+    : "vendor";
+const deriveAdditionalSkillReadPaths = (agent) => "additionalReadPaths" in agent.capabilities.skill.native
+    ? (agent.capabilities.skill.native.additionalReadPaths ?? [])
+    : [];
+const detectionMarkerKey = (marker) => marker.kind === "executable" ? `executable:${marker.name}` : `${marker.kind}:${marker.path}`;
+const fileMarker = (path) => ({
+    kind: "file",
+    path,
+    signal: "supporting",
+    note: null,
+});
+const appendMarker = (markers, marker) => {
+    markers.set(detectionMarkerKey(marker), marker);
+};
+const appendFileMarkers = (markersByScope, locations) => {
+    for (const location of locations) {
+        appendMarker(markersByScope[location.scope], fileMarker(location.path));
+    }
+};
+const hasConfigFiles = (capability) => "configFiles" in capability;
+const deriveDetection = (agent, rootDir) => {
+    const projectMarkers = new Map();
+    const userMarkers = new Map();
+    const markersByScope = {
+        project: projectMarkers,
+        user: userMarkers,
+    };
+    if (rootDir !== undefined) {
+        appendMarker(projectMarkers, {
+            kind: "dir",
+            path: rootDir,
+            signal: "definitive",
+            note: null,
+        });
+    }
+    const mcp = agent.capabilities["mcp-server"];
+    if (mcp.axm.writer !== null) {
+        appendFileMarkers(markersByScope, mcp.axm.writer.config.targets.filter((target) => target.attribution === "agent"));
+    }
+    for (const capability of Object.values(agent.capabilities)) {
+        if (hasConfigFiles(capability.native)) {
+            appendFileMarkers(markersByScope, capability.native.configFiles);
+        }
+    }
+    if (hasConfigFiles(agent.permissions.native)) {
+        appendFileMarkers(markersByScope, agent.permissions.native.configFiles);
+    }
+    for (const marker of agent.detection.project.markers) {
+        appendMarker(projectMarkers, marker);
+    }
+    for (const marker of agent.detection.user.markers) {
+        appendMarker(userMarkers, marker);
+    }
+    const project = Array.from(projectMarkers.values());
+    const user = Array.from(userMarkers.values());
+    return {
+        project: { markers: project },
+        user: { markers: user },
+    };
+};
+const deriveSubagentsDescriptor = (agent) => {
+    const subagents = agent.capabilities.subagent;
+    if (!isCapabilitySupported(subagents))
+        return undefined;
+    if (!("directory" in subagents.native))
+        return undefined;
+    return {
+        dir: subagents.native.directory,
+        scopes: subagents.native.scopes,
+        ...(subagents.native.layout === "file" ? { isFile: true } : {}),
+    };
+};
+const deriveInstructionsDescriptor = (agent) => {
+    const instructions = agent.instructions;
+    if (!isCapabilitySupported(instructions) || !("kind" in instructions.native))
+        return undefined;
+    // A secondary native rules directory beside the instruction file. Carried
+    // through so status output can report it as unsynced; AXM writes only the
+    // instruction file itself.
+    const rulesDir = "directory" in instructions.native ? { rulesDir: instructions.native.directory } : {};
+    switch (instructions.native.kind) {
+        case "agents-md":
+            return { kind: "agents-md", ...rulesDir };
+        case "own-file": {
+            const file = instructions.native.files[0];
+            if (file === undefined)
+                return undefined;
+            return {
+                kind: "own-file",
+                file,
+                ...(instructions.native.importSyntax === null
+                    ? {}
+                    : { importSyntax: instructions.native.importSyntax }),
+                ...rulesDir,
+            };
+        }
+        case "rules-dir": {
+            return {
+                kind: "rules-dir",
+                dir: instructions.native.directory,
+                format: "frontmatter",
+            };
+        }
+    }
+};
+/** @experimental This API is unstable and may change without notice. */
+export const deriveAgentDescriptor = (agent) => {
+    const subagents = deriveSubagentsDescriptor(agent);
+    const instructions = deriveInstructionsDescriptor(agent);
+    const rootDir = deriveRootDir(agent);
+    const detection = deriveDetection(agent, rootDir);
+    const skills = isCapabilitySupported(agent.capabilities.skill) &&
+        "directory" in agent.capabilities.skill.native
+        ? {
+            dir: agent.capabilities.skill.native.directory,
+            additionalReadPaths: deriveAdditionalSkillReadPaths(agent),
+        }
+        : undefined;
+    return {
+        id: deriveAgentId(agent),
+        name: agent.name,
+        rootDir,
+        detection,
+        ...(skills === undefined ? {} : { skills }),
+        ...(subagents === undefined ? {} : { subagents }),
+        ...(instructions === undefined ? {} : { instructions }),
+    };
+};
+/** @experimental This API is unstable and may change without notice. */
+export const listCapabilities = (agent) => {
+    const capabilities = [];
+    for (const type of LEAF_EXTENSION_TYPES) {
+        const capability = capabilityForType(agent, type);
+        if (capability === undefined)
+            continue;
+        if (capability.axm.status !== "unsupported" ||
+            capability.axm.writer !== null ||
+            capability.axm.lastVerified !== null ||
+            capability.native.availability.via !== "none" ||
+            capability.native.sources.length > 0 ||
+            capability.native.docs.length > 0 ||
+            capability.native.notes !== null) {
+            capabilities.push({ type, capability });
+        }
+    }
+    return capabilities;
+};
+/** @experimental This API is unstable and may change without notice. */
+export const agentSupportsType = (agent, type) => {
+    const capability = agent.capabilities[type];
+    return isCapabilitySupported(capability);
+};
+/** @experimental This API is unstable and may change without notice. */
+export const getSupportedExtensionTypesForAgent = (agent) => LEAF_EXTENSION_TYPES.filter((type) => {
+    const capability = capabilityForType(agent, type);
+    return capability !== undefined && isCapabilitySupported(capability);
+});
+// A type the catalog models no capability for is treated as unsupported.
+const agentSatisfiesType = (agent, type) => {
+    const capability = capabilityForType(agent, type);
+    return capability !== undefined && isCapabilitySupported(capability);
+};
+/**
+ * Agents an extension of the given types can be installed for.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const getSupportedAgentsForExtensionTypes = (types, catalog = AGENTS) => {
+    if (types.length === 0)
+        return [];
+    return catalog.filter((agent) => types.every((type) => agentSatisfiesType(agent, type)));
+};
+/** @experimental This API is unstable and may change without notice. */
+export const getSupportedAgentsForExtensionType = (type, catalog = AGENTS) => getSupportedAgentsForExtensionTypes([type], catalog);
+/** @experimental This API is unstable and may change without notice. */
+export const getSupportedAgentsForExtension = (extension, catalog = AGENTS) => extension.type === "pack"
+    ? getSupportedAgentsForExtensionTypes(extension.memberTypes, catalog)
+    : getSupportedAgentsForExtensionType(extension.type, catalog);
+const hookDecisionKinds = (decisions) => new Set(decisions.map((decision) => decision.kind));
+const missingValues = (required, available) => required.filter((value) => !available.has(value));
+const unique = (values) => Array.from(new Set(values));
+/** @experimental This API is unstable and may change without notice. */
+export const canonicalCoverage = (agent) => {
+    const hook = agent.capabilities.hook;
+    if (!("events" in hook.native)) {
+        return {
+            events: [],
+            tools: [],
+            mechanism: [],
+            matcherKinds: [],
+            decision: [],
+        };
+    }
+    return {
+        events: unique(hook.native.events.map((event) => event.canonical)),
+        tools: unique(hook.native.tools.map((tool) => tool.canonical)),
+        mechanism: unique(hook.native.mechanism),
+        matcherKinds: unique(hook.native.events.map((event) => event.matcher.kind)),
+        decision: hook.native.events.flatMap((event) => event.decision),
+    };
+};
+const hookEventForBinding = (agent, binding) => {
+    const native = agent.capabilities.hook.native;
+    if (!("events" in native))
+        return undefined;
+    return native.events.find((event) => event.canonical === binding.on);
+};
+const targetMatcherRaw = (agent, binding) => binding.targets?.[agent.id]?.matcherRaw ?? binding.matcherRaw;
+const bindingRequiresMatcher = (agent, binding) => targetMatcherRaw(agent, binding) !== undefined || (binding.match?.tools?.length ?? 0) > 0;
+const decisionRequirementSatisfied = (available, required) => available.some((decision) => decision.kind === required.kind);
+/** @experimental This API is unstable and may change without notice. */
+export const installable = (agent, binding) => {
+    const hook = agent.capabilities.hook;
+    if (hook.native.availability.via === "none") {
+        return { installable: false, reason: `${agent.name} has no hook system.` };
+    }
+    if (!("events" in hook.native)) {
+        return { installable: false, reason: `${agent.name} has no modeled hook events.` };
+    }
+    if (hook.axm.writer === null) {
+        return { installable: false, reason: `AXM has not built a hook writer for ${agent.name}.` };
+    }
+    const event = hookEventForBinding(agent, binding);
+    if (event === undefined) {
+        return {
+            installable: false,
+            reason: `${agent.name} does not support ${binding.on}.`,
+        };
+    }
+    if (bindingRequiresMatcher(agent, binding) && event.matcher.kind === "none-imperative") {
+        return {
+            installable: false,
+            reason: `${agent.name} cannot express a matcher for ${binding.on}.`,
+        };
+    }
+    const tools = binding.match?.tools ?? [];
+    if (tools.length > 0) {
+        const nativeTools = new Set(hook.native.tools.map((tool) => tool.canonical));
+        const missingTools = missingValues(tools, nativeTools);
+        if (missingTools.length > 0) {
+            return {
+                installable: false,
+                reason: `${agent.name} cannot express matcher tool(s): ${missingTools.join(", ")}.`,
+            };
+        }
+    }
+    const requiredDecision = binding.requires?.decision;
+    if (requiredDecision !== undefined &&
+        !decisionRequirementSatisfied(event.decision, requiredDecision)) {
+        return {
+            installable: false,
+            reason: `${agent.name} cannot satisfy ${requiredDecision.kind} decisions for ${binding.on}.`,
+        };
+    }
+    return { installable: true, reason: `${agent.name} can install ${binding.on}.` };
+};
+/** @experimental This API is unstable and may change without notice. */
+export const deriveHookPortability = (agent, requirement) => {
+    const hook = agent.capabilities.hook;
+    if (hook.native.availability.via === "none") {
+        return {
+            standardsCompliance: "none",
+            reason: `${agent.name} has no known native hook surface.`,
+        };
+    }
+    if (!("events" in hook.native)) {
+        return {
+            standardsCompliance: "none",
+            reason: `${agent.name} has no modeled native hook events.`,
+        };
+    }
+    const coverage = canonicalCoverage(agent);
+    const eventIds = new Set(coverage.events);
+    const missingEvents = missingValues(requirement.events, eventIds);
+    if (missingEvents.length > 0) {
+        return {
+            standardsCompliance: "none",
+            reason: `${agent.name} does not expose required hook event(s): ${missingEvents.join(", ")}.`,
+        };
+    }
+    const mechanisms = new Set(coverage.mechanism);
+    const missingMechanisms = missingValues(requirement.mechanisms, mechanisms);
+    const decisions = hook.native.events.flatMap((event) => event.decision);
+    const availableDecisionKinds = hookDecisionKinds(decisions);
+    const missingDecisions = missingValues(requirement.decisions, availableDecisionKinds);
+    const partialReasons = [
+        ...(missingMechanisms.length === 0
+            ? []
+            : [`missing mechanism(s): ${missingMechanisms.join(", ")}`]),
+        ...(missingDecisions.length === 0
+            ? []
+            : [`missing decision(s): ${missingDecisions.join(", ")}`]),
+        ...(hook.axm.writer !== null ? [] : ["AXM has no writer"]),
+    ];
+    if (partialReasons.length > 0) {
+        return {
+            standardsCompliance: "partial",
+            reason: `${agent.name} has a native hook surface, but ${partialReasons.join("; ")}.`,
+        };
+    }
+    return {
+        standardsCompliance: "full",
+        reason: `${agent.name} supports the required hook events, mechanism, decisions, and AXM writer.`,
+    };
+};
+/** @experimental This API is unstable and may change without notice. */
+export const toNativeAgent = (agent) => ({
+    id: agent.id,
+    name: agent.name,
+    vendor: agent.vendor,
+    homepage: agent.homepage,
+    interfaces: agent.interfaces,
+    family: agent.family,
+    rootDir: agent.rootDir,
+    ...(agent.installTarget === undefined ? {} : { installTarget: agent.installTarget }),
+    lifecycle: agent.lifecycle,
+    detection: agent.detection,
+    docs: agent.docs,
+    capabilities: {
+        skill: agent.capabilities.skill.native,
+        "mcp-server": agent.capabilities["mcp-server"].native,
+        subagent: agent.capabilities.subagent.native,
+        hook: agent.capabilities.hook.native,
+    },
+    instructions: agent.instructions.native,
+    permissions: agent.permissions.native,
+});
+//# sourceMappingURL=derive.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Agent capability catalog for @agentxm/extension-model.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AgentIdFromYamlSchema, AgentCapabilitiesSchema, AgentInterfaceSchema, AgentLifecycleSchema, AgentLifecycleStateSchema, AgentSchema, ActiveAxmSupportSchema, AvailabilitySchema, AxmSupportSchema, CANONICAL_HOOK_EVENTS, CANONICAL_HOOK_EVENT_IDS, CANONICAL_HOOK_TOOL_IDS, CapabilityTargetingEntrySchema, CapabilityTargetingSchema, CanonicalHookEventIdSchema, CanonicalHookEventSchema, CanonicalHookToolIdSchema, ConfigFileFormatSchema, ConfigFileLocationSchema, ConventionSchema, DetectionMarkerSchema, DetectionSchema, DetectionSignalSchema, InactiveAxmSupportSchema, LastVerifiedDateSchema, HookBlockOutcomeSchema, HookCommandNameSerializationSchema, HookDecisionCapabilitySchema, HookEventMappingSchema, HookEventTierSchema, HookMatcherKindSchema, HookMatcherSerializationSchema, HookMatcherSchema, HookMechanismFamilySchema, HookModifyOperationSchema, HookTimeoutSerializationSchema, HookToolMappingSchema, HostedInstallArtifactSchema, HostedInstallDeliverySchema, HostedInstallTargetSchema, McpEnvExpansionSchema, McpExtensionCapabilitySchema, McpActivationFieldRepresentationSchema, McpActivationFieldSchema, McpTypeFieldRepresentationSchema, McpTypeFieldSchema, McpTransportSchema, NativeCapabilityBaseSchema, PermissionCliFlagSchema, PermissionGrammarSchema, PermissionGrammarStyleSchema, PermissionGrantSchema, PermissionMechanismSchema, PermissionPrerequisiteSchema, PermissionsExtensionCapabilitySchema, PluginDescriptorSchema, PluginDetectionConfigKeySchema, PluginDetectionPathSchema, PluginDetectionSchema, PluginDistributionMechanismSchema, PluginDistributionSchema, ProvenanceSchema, RuleInstructionsImportSyntaxSchema, RuleInstructionsKindSchema, RulesExtensionCapabilitySchema, ScopeSchema, ScopeDetectionSchema, SkillReadPathSchema, SkillReadPathStatusSchema, SkillsExtensionCapabilitySchema, StandardsComplianceSchema, SubagentsExtensionCapabilitySchema, SubagentsLayoutSchema, SUPPORTED_AXM_SUPPORT, VendorStatusSchema, type Agent, type AgentCapabilities, type AgentExtensionCapability, type ActiveAxmSupport, type AgentIdFromYaml, type AgentInterface, type AgentLifecycle, type AgentLifecycleState, type Availability, type AxmCapabilityState, type AxmSupport, type CanonicalHookEvent, type CanonicalHookEventId, type CanonicalHookToolId, type ConfigFileFormat, type ConfigFileLocation, type Convention, type Detection, type DetectionMarker, type DetectionSignal, type HookBlockOutcome, type HookCommandNameSerialization, type HookDecisionCapability, type HookEventMapping, type HookEventTier, type HookMatcher, type HookMatcherKind, type HookMatcherSerialization, type HookMechanismFamily, type HookModifyOperation, type HookTimeoutSerialization, type HookToolMapping, type HostedInstallArtifact, type HostedInstallDelivery, type HostedInstallTarget, type HooksSerializer, type HooksWriter, type InactiveAxmSupport, type LastVerifiedDate, type McpEnvExpansion, type McpExtensionCapability, type McpActivationField, type McpActivationFieldRepresentation, type McpConfig, type McpConfigTarget, type McpTargetAttribution, type McpRemoteDialect, type McpServersKey, type McpStdioDialect, type McpTypeField, type McpTypeFieldRepresentation, type McpTransport, type PermissionCliFlag, type PermissionGrammar, type PermissionGrammarStyle, type PermissionGrant, type PermissionMechanism, type PermissionPrerequisite, type PermissionsExtensionCapability, type NativeCapability, type NativeCapabilityBase, type PluginDescriptor, type PluginDetection, type PluginDetectionConfigKey, type PluginDetectionPath, type PluginDistribution, type PluginDistributionMechanism, type Provenance, type RuleInstructionsImportSyntax, type RuleInstructionsKind, type RulesExtensionCapability, type Scope, type ScopeDetection, type SkillReadPath, type SkillReadPathStatus, type SkillsExtensionCapability, type StandardsCompliance, type SubagentsExtensionCapability, type SubagentsLayout, type VendorStatus, } from "./schema.js";
+export { DocLinkSchema, LEAF_EXTENSION_TYPES, StandardSchema, UrlSchema, type DocLink, type LeafExtensionType, type Standard, type Url, } from "../extension-types/schema.js";
+export { type PerAgentType } from "../extensions/common.js";
+export { STANDARDS } from "../extension-types/standards.js";
+export { CAPABILITY_VERIFICATION_BUDGET_DAYS, capabilityVerificationAgeReport, type AgentCapabilitySlot, type CapabilityVerificationAge, } from "./verification.js";
+export { agentCapabilityStatus, agentSupportsType, axmIntegrationStatus, canonicalCoverage, deriveAgentDescriptor, deriveSkillConvention, deriveHookPortability, getSupportedAgentsForExtension, getSupportedAgentsForExtensionType, getSupportedAgentsForExtensionTypes, getSupportedExtensionTypesForAgent, isCapabilitySupported, isLeafExtensionType, listCapabilities, installable, toNativeAgent, type AgentCapabilityStatus, type AxmIntegrationStatus, type CapabilityListing, type ExtensionCompatibilityInput, type HookDecisionKind, type HookDecisionRequirement, type HookInstallabilityVerdict, type HookInstallBinding, type HookPortabilityRequirement, type HookPortabilityVerdict, type NativeAgent, type NativeAgentCapabilities, } from "./derive.js";
+export { AGENTS, AGENTS_BY_ID, AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENTS_BY_ID, CONFIGURABLE_AGENT_IDS, HOSTED_AGENTS_BY_ID, HOSTED_AGENT_IDS, type AgentId, type ConfigurableAgentId, type HostedAgentId, } from "./catalog.js";
+export { agentById } from "./lookup.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * Agent capability catalog for @agentxm/extension-model.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AgentIdFromYamlSchema, AgentCapabilitiesSchema, AgentInterfaceSchema, AgentLifecycleSchema, AgentLifecycleStateSchema, AgentSchema, ActiveAxmSupportSchema, AvailabilitySchema, AxmSupportSchema, CANONICAL_HOOK_EVENTS, CANONICAL_HOOK_EVENT_IDS, CANONICAL_HOOK_TOOL_IDS, CapabilityTargetingEntrySchema, CapabilityTargetingSchema, CanonicalHookEventIdSchema, CanonicalHookEventSchema, CanonicalHookToolIdSchema, ConfigFileFormatSchema, ConfigFileLocationSchema, ConventionSchema, DetectionMarkerSchema, DetectionSchema, DetectionSignalSchema, InactiveAxmSupportSchema, LastVerifiedDateSchema, HookBlockOutcomeSchema, HookCommandNameSerializationSchema, HookDecisionCapabilitySchema, HookEventMappingSchema, HookEventTierSchema, HookMatcherKindSchema, HookMatcherSerializationSchema, HookMatcherSchema, HookMechanismFamilySchema, HookModifyOperationSchema, HookTimeoutSerializationSchema, HookToolMappingSchema, HostedInstallArtifactSchema, HostedInstallDeliverySchema, HostedInstallTargetSchema, McpEnvExpansionSchema, McpExtensionCapabilitySchema, McpActivationFieldRepresentationSchema, McpActivationFieldSchema, McpTypeFieldRepresentationSchema, McpTypeFieldSchema, McpTransportSchema, NativeCapabilityBaseSchema, PermissionCliFlagSchema, PermissionGrammarSchema, PermissionGrammarStyleSchema, PermissionGrantSchema, PermissionMechanismSchema, PermissionPrerequisiteSchema, PermissionsExtensionCapabilitySchema, PluginDescriptorSchema, PluginDetectionConfigKeySchema, PluginDetectionPathSchema, PluginDetectionSchema, PluginDistributionMechanismSchema, PluginDistributionSchema, ProvenanceSchema, RuleInstructionsImportSyntaxSchema, RuleInstructionsKindSchema, RulesExtensionCapabilitySchema, ScopeSchema, ScopeDetectionSchema, SkillReadPathSchema, SkillReadPathStatusSchema, SkillsExtensionCapabilitySchema, StandardsComplianceSchema, SubagentsExtensionCapabilitySchema, SubagentsLayoutSchema, SUPPORTED_AXM_SUPPORT, VendorStatusSchema, } from "./schema.js";
+export { DocLinkSchema, LEAF_EXTENSION_TYPES, StandardSchema, UrlSchema, } from "../extension-types/schema.js";
+export {} from "../extensions/common.js";
+export { STANDARDS } from "../extension-types/standards.js";
+export { CAPABILITY_VERIFICATION_BUDGET_DAYS, capabilityVerificationAgeReport, } from "./verification.js";
+export { agentCapabilityStatus, agentSupportsType, axmIntegrationStatus, canonicalCoverage, deriveAgentDescriptor, deriveSkillConvention, deriveHookPortability, getSupportedAgentsForExtension, getSupportedAgentsForExtensionType, getSupportedAgentsForExtensionTypes, getSupportedExtensionTypesForAgent, isCapabilitySupported, isLeafExtensionType, listCapabilities, installable, toNativeAgent, } from "./derive.js";
+export { AGENTS, AGENTS_BY_ID, AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENTS_BY_ID, CONFIGURABLE_AGENT_IDS, HOSTED_AGENTS_BY_ID, HOSTED_AGENT_IDS, } from "./catalog.js";
+export { agentById } from "./lookup.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Catalog lookup helpers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type AgentId } from "./catalog.js";
+import type { Agent } from "./schema.js";
+/** @experimental This API is unstable and may change without notice. */
+export declare const agentById: (id: AgentId) => Agent;
+//# sourceMappingURL=lookup.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Catalog lookup helpers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { AGENTS_BY_ID } from "./catalog.js";
+/** @experimental This API is unstable and may change without notice. */
+export const agentById = (id) => AGENTS_BY_ID[id];
+//# sourceMappingURL=lookup.js.map