@orchid-labs/pluxx 0.1.0 → 0.1.1

package/src/mcp/introspect.ts

@@ -5,7 +5,7 @@ import type { McpAuth, McpServer } from '../schema'
 const MCP_PROTOCOL_VERSION = '2025-03-26'
 const CLIENT_INFO = {
   name: 'pluxx',
-  version: '0.1.0',
+  version: '0.1.1',
 }
 const DEFAULT_TIMEOUT_MS = 10_000
 
@@ -16,6 +16,33 @@ export interface IntrospectedMcpTool {
   inputSchema?: Record<string, unknown>
 }
 
+export interface IntrospectedMcpResource {
+  uri: string
+  name?: string
+  title?: string
+  description?: string
+  mimeType?: string
+}
+
+export interface IntrospectedMcpResourceTemplate {
+  uriTemplate: string
+  name: string
+  title?: string
+  description?: string
+  mimeType?: string
+}
+
+export interface IntrospectedMcpPrompt {
+  name: string
+  title?: string
+  description?: string
+  arguments?: Array<{
+    name: string
+    description?: string
+    required?: boolean
+  }>
+}
+
 export interface IntrospectedMcpServer {
   protocolVersion: string
   instructions?: string
@@ -27,6 +54,17 @@ export interface IntrospectedMcpServer {
     websiteUrl?: string
   }
   tools: IntrospectedMcpTool[]
+  resources?: IntrospectedMcpResource[]
+  resourceTemplates?: IntrospectedMcpResourceTemplate[]
+  prompts?: IntrospectedMcpPrompt[]
+}
+
+export interface McpAuthDiscovery {
+  kind: 'bearer' | 'header' | 'platform'
+  mode?: 'oauth'
+  headerName?: string
+  authorizationUrl?: string
+  resourceMetadataUrl?: string
 }
 
 export class McpIntrospectionError extends Error {
@@ -38,12 +76,52 @@ export class McpIntrospectionError extends Error {
       responseBodySnippet?: string
       responseUrl?: string
     },
+    readonly rpcCode?: number,
   ) {
     super(message)
     this.name = 'McpIntrospectionError'
   }
 }
 
+export function discoverMcpAuthFromError(error: McpIntrospectionError): McpAuthDiscovery | null {
+  const wwwAuthenticate = error.context?.responseHeaders?.['www-authenticate']?.trim() ?? ''
+  const locationHeader = error.context?.responseHeaders?.location?.trim()
+  const responseUrl = error.context?.responseUrl?.trim()
+  const responseBody = error.context?.responseBodySnippet ?? ''
+  const message = error.message
+
+  const authorizationUri = extractAuthParam(wwwAuthenticate, 'authorization_uri')
+  const resourceMetadataUrl = extractAuthParam(wwwAuthenticate, 'resource_metadata')
+  const oauthUrl = authorizationUri
+    ?? pickOAuthUrl(locationHeader, responseUrl)
+
+  if (looksLikeOAuthSignal([wwwAuthenticate, locationHeader, responseUrl, responseBody, message])) {
+    return {
+      kind: 'platform',
+      mode: 'oauth',
+      ...(oauthUrl ? { authorizationUrl: oauthUrl } : {}),
+      ...(resourceMetadataUrl ? { resourceMetadataUrl } : {}),
+    }
+  }
+
+  const headerName = extractHeaderName([wwwAuthenticate, responseBody, message])
+  if (headerName && headerName.toLowerCase() !== 'authorization') {
+    return {
+      kind: 'header',
+      headerName,
+    }
+  }
+
+  if (wwwAuthenticate.toLowerCase().includes('bearer') || headerName === 'Authorization') {
+    return {
+      kind: 'bearer',
+      headerName: 'Authorization',
+    }
+  }
+
+  return null
+}
+
 interface JsonRpcSuccess<T> {
   jsonrpc: '2.0'
   id: number | string
@@ -65,6 +143,11 @@ type JsonRpcEnvelope<T> = JsonRpcSuccess<T> | JsonRpcFailure
 interface InitializeResult {
   protocolVersion?: string
   instructions?: string
+  capabilities?: {
+    tools?: Record<string, unknown>
+    resources?: Record<string, unknown>
+    prompts?: Record<string, unknown>
+  }
   serverInfo?: {
     name?: string
     title?: string
@@ -84,39 +167,80 @@ interface ListToolsResult {
   nextCursor?: string
 }
 
-interface McpClient {
+interface ListResourcesResult {
+  resources?: Array<{
+    uri: string
+    name?: string
+    title?: string
+    description?: string
+    mimeType?: string
+  }>
+  nextCursor?: string
+}
+
+interface ListResourceTemplatesResult {
+  resourceTemplates?: Array<{
+    uriTemplate: string
+    name: string
+    title?: string
+    description?: string
+    mimeType?: string
+  }>
+  nextCursor?: string
+}
+
+interface ListPromptsResult {
+  prompts?: Array<{
+    name: string
+    title?: string
+    description?: string
+    arguments?: Array<{
+      name: string
+      description?: string
+      required?: boolean
+    }>
+  }>
+  nextCursor?: string
+}
+
+export interface McpClient {
   request<T>(method: string, params?: Record<string, unknown>): Promise<T>
   notify(method: string, params?: Record<string, unknown>): Promise<void>
   close(): Promise<void>
 }
 
 export async function introspectMcpServer(server: McpServer): Promise<IntrospectedMcpServer> {
+  if (server.transport === 'http') {
+    try {
+      return await introspectWithClient(await createMcpClient(server))
+    } catch (error) {
+      if (
+        error instanceof McpIntrospectionError
+        && (error.status === 400 || error.status === 404 || error.status === 405)
+      ) {
+        return await introspectWithClient(await createSseClient({
+          ...server,
+          transport: 'sse',
+        }))
+      }
+
+      throw error
+    }
+  }
+
+  return await introspectWithClient(await createMcpClient(server))
+}
+
+export async function createMcpClient(server: McpServer): Promise<McpClient> {
   if (server.transport === 'stdio') {
-    const client = await createStdioClient(server)
-    return await introspectWithClient(client)
+    return await createStdioClient(server)
   }
 
   if (server.transport === 'sse') {
-    const client = await createSseClient(server)
-    return await introspectWithClient(client)
+    return await createSseClient(server)
   }
 
-  try {
-    return await introspectWithClient(createHttpClient(server))
-  } catch (error) {
-    if (
-      error instanceof McpIntrospectionError
-      && (error.status === 400 || error.status === 404 || error.status === 405)
-    ) {
-      const sseClient = await createSseClient({
-        ...server,
-        transport: 'sse',
-      })
-      return await introspectWithClient(sseClient)
-    }
-
-    throw error
-  }
+  return createHttpClient(server)
 }
 
 async function introspectWithClient(client: McpClient): Promise<IntrospectedMcpServer> {
@@ -135,6 +259,15 @@ async function introspectWithClient(client: McpClient): Promise<IntrospectedMcpS
         'The MCP server initialized successfully but exposed no tools. pluxx init --from-mcp currently scaffolds from tool metadata only.',
       )
     }
+    const resources = hasInitializeCapability(initialize, 'resources')
+      ? await listAllResources(client)
+      : []
+    const resourceTemplates = hasInitializeCapability(initialize, 'resources')
+      ? await listAllResourceTemplates(client)
+      : []
+    const prompts = hasInitializeCapability(initialize, 'prompts')
+      ? await listAllPrompts(client)
+      : []
 
     return {
       protocolVersion: initialize.protocolVersion ?? MCP_PROTOCOL_VERSION,
@@ -147,12 +280,79 @@ async function introspectWithClient(client: McpClient): Promise<IntrospectedMcpS
         websiteUrl: initialize.serverInfo?.websiteUrl,
       },
       tools,
+      resources,
+      resourceTemplates,
+      prompts,
     }
   } finally {
     await client.close()
   }
 }
 
+function hasInitializeCapability(
+  initialize: InitializeResult,
+  capability: 'resources' | 'prompts',
+): boolean {
+  const value = initialize.capabilities?.[capability]
+  return typeof value === 'object' && value !== null
+}
+
+function looksLikeOAuthSignal(values: Array<string | undefined>): boolean {
+  return values.some((value) => {
+    const normalized = value?.toLowerCase() ?? ''
+    return /\boauth\b/.test(normalized)
+      || normalized.includes('authorization_uri=')
+      || /\bauthorize\b/.test(normalized)
+      || /\blogin\b/.test(normalized)
+      || /\bsignin\b/.test(normalized)
+  })
+}
+
+function pickOAuthUrl(...candidates: Array<string | undefined>): string | undefined {
+  for (const value of candidates) {
+    if (!value) continue
+    const normalized = value.toLowerCase()
+    if (
+      /\boauth\b/.test(normalized)
+      || /\bauthorize\b/.test(normalized)
+      || /\blogin\b/.test(normalized)
+      || /\bsignin\b/.test(normalized)
+    ) {
+      return value
+    }
+  }
+  return undefined
+}
+
+function extractAuthParam(header: string, name: string): string | undefined {
+  if (!header) return undefined
+  const pattern = new RegExp(`${name}=\"([^\"]+)\"`, 'i')
+  return header.match(pattern)?.[1]
+}
+
+function extractHeaderName(values: string[]): string | undefined {
+  for (const value of values) {
+    const matches = value.match(/\b(?:x-[a-z0-9-]+|authorization)\b/gi)
+    if (!matches) continue
+    const candidate = matches[0]
+    if (!candidate) continue
+    if (candidate.toLowerCase() === 'authorization') {
+      return 'Authorization'
+    }
+    return candidate
+      .split('-')
+      .map((part) => {
+        const normalized = part.toLowerCase()
+        if (normalized === 'api' || normalized === 'id' || normalized === 'url') {
+          return normalized.toUpperCase()
+        }
+        return normalized.charAt(0).toUpperCase() + normalized.slice(1)
+      })
+      .join('-')
+  }
+  return undefined
+}
+
 async function listAllTools(client: McpClient): Promise<IntrospectedMcpTool[]> {
   const tools: IntrospectedMcpTool[] = []
   let cursor: string | undefined
@@ -167,6 +367,61 @@ async function listAllTools(client: McpClient): Promise<IntrospectedMcpTool[]> {
   }
 }
 
+async function listAllResources(client: McpClient): Promise<IntrospectedMcpResource[]> {
+  return await listOptionalPaged(client, 'resources/list', (result: ListResourcesResult) => result.resources ?? [])
+}
+
+async function listAllResourceTemplates(client: McpClient): Promise<IntrospectedMcpResourceTemplate[]> {
+  return await listOptionalPaged(
+    client,
+    'resources/templates/list',
+    (result: ListResourceTemplatesResult) => result.resourceTemplates ?? [],
+  )
+}
+
+async function listAllPrompts(client: McpClient): Promise<IntrospectedMcpPrompt[]> {
+  return await listOptionalPaged(client, 'prompts/list', (result: ListPromptsResult) => result.prompts ?? [])
+}
+
+async function listOptionalPaged<TResult extends { nextCursor?: string }, TItem>(
+  client: McpClient,
+  method: string,
+  getItems: (result: TResult) => TItem[],
+): Promise<TItem[]> {
+  const items: TItem[] = []
+  let cursor: string | undefined
+
+  while (true) {
+    let result: TResult
+    try {
+      result = await client.request<TResult>(method, cursor ? { cursor } : undefined)
+    } catch (error) {
+      if (isOptionalDiscoveryUnavailable(error)) {
+        return items
+      }
+      throw error
+    }
+
+    items.push(...getItems(result))
+    cursor = result.nextCursor
+    if (!cursor) {
+      return items
+    }
+  }
+}
+
+function isOptionalDiscoveryUnavailable(error: unknown): boolean {
+  if (!(error instanceof McpIntrospectionError)) {
+    return false
+  }
+
+  const message = error.message.toLowerCase()
+  return error.rpcCode === -32601
+    || message.includes('method not found')
+    || message.includes('not supported')
+    || message.includes('unsupported')
+}
+
 function createHttpClient(server: Exclude<McpServer, { transport: 'stdio' }>): McpClient {
   let sessionId: string | null = null
 
@@ -541,6 +796,7 @@ async function createStdioClient(server: Extract<McpServer, { transport: 'stdio'
     },
     stdio: ['pipe', 'pipe', 'pipe'],
   })
+  let isClosing = false
 
   const pending = new Map<number, { resolve: (value: unknown) => void; reject: (error: Error) => void }>()
   const stdout = readline.createInterface({
@@ -578,6 +834,10 @@ async function createStdioClient(server: Extract<McpServer, { transport: 'stdio'
   })
 
   child.once('exit', (code, signal) => {
+    if (isClosing) {
+      pending.clear()
+      return
+    }
     const error = new McpIntrospectionError(
       `MCP stdio process exited before pluxx finished introspecting it (code=${code ?? 'null'}, signal=${signal ?? 'null'}).`,
     )
@@ -637,8 +897,16 @@ async function createStdioClient(server: Extract<McpServer, { transport: 'stdio'
     },
 
     async close(): Promise<void> {
+      isClosing = true
       stdout.close()
-      child.kill()
+      child.stdin.end()
+      child.stdout.destroy()
+      child.stderr?.destroy()
+
+      if (child.exitCode === null && child.signalCode === null) {
+        child.kill('SIGKILL')
+        child.unref()
+      }
     },
   }
 }
@@ -821,7 +1089,12 @@ function parseSsePayload(payload: string): Array<JsonRpcEnvelope<unknown>> {
 
 function unwrapEnvelope<T>(envelope: JsonRpcEnvelope<T>): T {
   if ('error' in envelope) {
-    throw new McpIntrospectionError(`MCP request failed: ${envelope.error.message}`)
+    throw new McpIntrospectionError(
+      `MCP request failed: ${envelope.error.message}`,
+      undefined,
+      undefined,
+      envelope.error.code,
+    )
   }
 
   return envelope.result

package/src/permissions.ts

@@ -84,7 +84,9 @@ export function buildOpenCodePermissionMap(
     Edit: ['edit', 'write'],
     Read: ['read'],
     MCP: ['mcp'],
-    Skill: ['skill'],
+    // OpenCode's native permission surface is tool-level and does not expose
+    // a dedicated skill permission key.
+    Skill: [],
   }
 
   for (const rule of rules) {

package/src/validation/platform-rules.ts

@@ -7,6 +7,13 @@ export interface PlatformRuleSource {
   url: string
 }
 
+export type PlatformLimitKind = 'hard' | 'advisory' | 'display'
+
+export interface PlatformLimitPolicy {
+  kind: PlatformLimitKind
+  notes?: string
+}
+
 export interface PlatformLimits {
   skillDescriptionMax: number | null
   skillDescriptionDisplayMax: number | null
@@ -21,10 +28,25 @@ export interface PlatformLimits {
   rulesMaxLines: number | null
 }
 
+export interface PlatformLimitPolicies {
+  skillDescriptionMax: PlatformLimitPolicy | null
+  skillDescriptionDisplayMax: PlatformLimitPolicy | null
+  skillListingBudgetMax: PlatformLimitPolicy | null
+  skillNameMax: PlatformLimitPolicy
+  skillNameMustMatchDir: PlatformLimitPolicy
+  manifestPromptMax: PlatformLimitPolicy | null
+  manifestPromptCountMax: PlatformLimitPolicy | null
+  manifestPathPrefix: PlatformLimitPolicy | null
+  instructionsMaxBytes: PlatformLimitPolicy | null
+  hooksFeatureFlag: PlatformLimitPolicy | null
+  rulesMaxLines: PlatformLimitPolicy | null
+}
+
 export interface PlatformRules {
   platform: TargetPlatform
   summary: string
   limits: PlatformLimits
+  limitPolicies: PlatformLimitPolicies
   skillDiscoveryDirs: {
     path: string
     level: RuleLevel
@@ -84,6 +106,20 @@ const NULL_LIMITS: PlatformLimits = {
   rulesMaxLines: null,
 }
 
+const NULL_LIMIT_POLICIES: PlatformLimitPolicies = {
+  skillDescriptionMax: null,
+  skillDescriptionDisplayMax: null,
+  skillListingBudgetMax: null,
+  skillNameMax: { kind: 'hard' },
+  skillNameMustMatchDir: { kind: 'hard' },
+  manifestPromptMax: null,
+  manifestPromptCountMax: null,
+  manifestPathPrefix: null,
+  instructionsMaxBytes: null,
+  hooksFeatureFlag: null,
+  rulesMaxLines: null,
+}
+
 export const PLATFORM_LIMITS: Record<TargetPlatform, PlatformLimits> = {
   'claude-code': {
     ...NULL_LIMITS,
@@ -138,6 +174,78 @@ export const PLATFORM_LIMITS: Record<TargetPlatform, PlatformLimits> = {
   },
 }
 
+export const PLATFORM_LIMIT_POLICIES: Record<TargetPlatform, PlatformLimitPolicies> = {
+  'claude-code': {
+    ...NULL_LIMIT_POLICIES,
+    skillDescriptionMax: {
+      kind: 'hard',
+      notes: 'Claude skills listing caps description + when_to_use combined at 1,536 characters.',
+    },
+    skillDescriptionDisplayMax: {
+      kind: 'display',
+      notes: 'Claude surfaces commonly truncate long listing text around 250 characters.',
+    },
+    skillListingBudgetMax: {
+      kind: 'advisory',
+      notes: 'Pluxx warns at 8,000 aggregate characters to keep Claude listings readable and avoid crowded discovery surfaces.',
+    },
+  },
+  'codex': {
+    ...NULL_LIMIT_POLICIES,
+    skillDescriptionMax: { kind: 'hard' },
+    skillNameMustMatchDir: { kind: 'hard' },
+    manifestPromptMax: { kind: 'hard' },
+    manifestPromptCountMax: { kind: 'hard' },
+    manifestPathPrefix: { kind: 'hard' },
+    instructionsMaxBytes: {
+      kind: 'hard',
+      notes: 'Codex AGENTS.md/project docs truncate at 32 KiB.',
+    },
+    hooksFeatureFlag: {
+      kind: 'hard',
+      notes: 'Hook support depends on the Codex hooks feature flag/runtime support.',
+    },
+  },
+  'cursor': {
+    ...NULL_LIMIT_POLICIES,
+    skillNameMustMatchDir: { kind: 'hard' },
+    rulesMaxLines: {
+      kind: 'advisory',
+      notes: 'Cursor docs treat 500 lines as practical guidance rather than a documented hard cap.',
+    },
+  },
+  'opencode': {
+    ...NULL_LIMIT_POLICIES,
+    skillDescriptionMax: { kind: 'hard' },
+    skillNameMustMatchDir: { kind: 'hard' },
+  },
+  'github-copilot': {
+    ...NULL_LIMIT_POLICIES,
+    skillDescriptionDisplayMax: { kind: 'display' },
+  },
+  'openhands': {
+    ...NULL_LIMIT_POLICIES,
+  },
+  'warp': {
+    ...NULL_LIMIT_POLICIES,
+  },
+  'gemini-cli': {
+    ...NULL_LIMIT_POLICIES,
+    skillNameMustMatchDir: { kind: 'hard' },
+  },
+  'roo-code': {
+    ...NULL_LIMIT_POLICIES,
+  },
+  'cline': {
+    ...NULL_LIMIT_POLICIES,
+    skillDescriptionMax: { kind: 'hard' },
+    skillNameMustMatchDir: { kind: 'hard' },
+  },
+  'amp': {
+    ...NULL_LIMIT_POLICIES,
+  },
+}
+
 type ResearchTarget = Extract<
   TargetPlatform,
   | 'claude-code'
@@ -157,6 +265,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'claude-code',
     summary: 'Claude Code plugins use an optional manifest at .claude-plugin/plugin.json with auto-discovery for skills, commands, agents, hooks, MCP, and output styles.',
     limits: PLATFORM_LIMITS['claude-code'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['claude-code'],
     skillDiscoveryDirs: [
       { path: 'skills/', level: 'supported' },
     ],
@@ -187,6 +296,9 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
       format: 'markdown',
     },
     sources: [
+      { label: 'Claude Code headless docs', url: 'https://code.claude.com/docs/en/headless' },
+      { label: 'Claude Code CLI reference', url: 'https://code.claude.com/docs/en/cli-reference' },
+      { label: 'Claude Code discover plugins docs', url: 'https://code.claude.com/docs/en/discover-plugins' },
       { label: 'Claude Code plugins reference', url: 'https://code.claude.com/docs/en/plugins-reference' },
       { label: 'Claude Code hooks docs', url: 'https://code.claude.com/docs/en/hooks' },
       { label: 'Claude Code skills docs', url: 'https://code.claude.com/docs/en/skills' },
@@ -196,6 +308,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'cursor',
     summary: 'Cursor plugins use .cursor-plugin/plugin.json plus auto-discovered rules, skills, agents, commands, hooks, and mcp.json at the plugin root; Cursor subagents are a related but separate surface under .cursor/agents and ~/.cursor/agents.',
     limits: PLATFORM_LIMITS['cursor'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['cursor'],
     skillDiscoveryDirs: [
       { path: 'skills/', level: 'supported' },
       { path: 'SKILL.md', level: 'fallback', notes: 'Used when no skills directory or manifest skill path is present.' },
@@ -243,6 +356,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'codex',
     summary: 'Codex plugins use .codex-plugin/plugin.json with skills, .mcp.json, optional app mappings, and AGENTS.md; current docs separate plugin packaging from hooks configuration and do not document plugin-provided slash commands.',
     limits: PLATFORM_LIMITS['codex'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['codex'],
     skillDiscoveryDirs: [
       { path: 'skills/', level: 'supported' },
     ],
@@ -284,6 +398,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'opencode',
     summary: 'OpenCode plugins are code-first TypeScript or JavaScript modules that register skills, commands, MCP servers, and hook handlers programmatically.',
     limits: PLATFORM_LIMITS['opencode'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['opencode'],
     skillDiscoveryDirs: [
       { path: 'skills/', level: 'supported' },
     ],
@@ -323,6 +438,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'openhands',
     summary: 'OpenHands plugins use a Claude-style manifest at .plugin/plugin.json and support skills, hooks, and MCP.',
     limits: PLATFORM_LIMITS['openhands'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['openhands'],
     skillDiscoveryDirs: [
       { path: '.openhands/skills/', level: 'supported' },
       { path: '.claude/skills/', level: 'supported' },
@@ -363,6 +479,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'warp',
     summary: 'Warp supports skills, rules, and MCP with AGENTS.md as the current rules anchor.',
     limits: PLATFORM_LIMITS['warp'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['warp'],
     skillDiscoveryDirs: [
       { path: '.agents/skills/', level: 'supported' },
       { path: '.warp/skills/', level: 'supported' },
@@ -405,6 +522,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'gemini-cli',
     summary: 'Gemini CLI uses gemini-extension.json, GEMINI.md instructions, and hook definitions in hooks/hooks.json.',
     limits: PLATFORM_LIMITS['gemini-cli'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['gemini-cli'],
     skillDiscoveryDirs: [
       { path: 'skills/', level: 'supported' },
     ],
@@ -443,6 +561,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'roo-code',
     summary: 'Roo Code supports project and mode-specific rules, project-level MCP config, and custom modes metadata.',
     limits: PLATFORM_LIMITS['roo-code'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['roo-code'],
     skillDiscoveryDirs: [
       { path: '.roo/skills/', level: 'supported' },
     ],
@@ -484,6 +603,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'cline',
     summary: 'Cline supports layered rules, .cline/mcp.json, and conditional rules via frontmatter path globs.',
     limits: PLATFORM_LIMITS['cline'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['cline'],
     skillDiscoveryDirs: [
       { path: '.cline/skills/', level: 'supported' },
       { path: '.agents/skills/', level: 'supported' },
@@ -524,6 +644,7 @@ export const PLATFORM_VALIDATION_RULES: Record<ResearchTarget, PlatformRules> =
     platform: 'amp',
     summary: 'AMP uses AGENTS.md/AGENT.md for instruction hierarchy and .amp/settings.json for settings, hooks, and MCP.',
     limits: PLATFORM_LIMITS['amp'],
+    limitPolicies: PLATFORM_LIMIT_POLICIES['amp'],
     skillDiscoveryDirs: [
       { path: '.agents/skills/', level: 'supported' },
       { path: '~/.config/amp/skills/', level: 'supported' },