เข้าสู่ระบบนัดหมายรับฟังข้อมูลสรุป (or นัดหมายพูดคุยกับทีมงาน)

บทที่ 2.20

ทักษะ (Skills)

วิธีเขียน ทดสอบ และเผยแพร่ทักษะของ Skills Engine ตำแหน่งที่ทักษะจะปรากฏเมื่อเปิดใช้งานจริง และความแตกต่างของทักษะใน Manifest ของปลั๊กอิน รวมถึงตัวอย่างการใช้งานจริงของการสรุปการจัดสรรท่าเทียบเรือสำหรับ Harrow Port Authority

หน้านี้แปลโดย AI จากต้นฉบับภาษาอังกฤษ หากมีส่วนใดไม่ชัดเจน โปรดอ้างอิงจากหน้าภาษาอังกฤษ อ่านหน้านี้เป็นภาษาอังกฤษ

ใช้เวลาอ่าน 17 นาที

Tomás Reilly วิศวกรแพลตฟอร์มของ Harrow Port Authority ถามผมเมื่อเดือนที่แล้วว่าทำไมผู้วางแผนท่าเทียบเรือของเขาจึงได้คำตอบที่แตกต่างกันทุกครั้งที่ถามผู้ช่วยว่า "พรุ่งนี้ใครอยู่ท่าเทียบเรือไหน และมีอะไรเปลี่ยนไปบ้าง" คำตอบคือไม่มีใครบอกผู้ช่วยว่าคำตอบที่ดีมีลักษณะอย่างไร สกิลของ Skills Engine แก้ปัญหานี้ได้ภายในบ่ายเดียว ปัจจุบันผู้วางแผนได้รับสรุปสามส่วนแบบเดียวกันทุกครั้ง โดยมีตารางท่าเทียบเรืออยู่ก่อน ตามด้วยการเปลี่ยนแปลงนับจากแผนล่าสุด และข้อขัดแย้งอยู่ท้ายสุด บทนี้จะอธิบายสกิลดังกล่าวตั้งแต่ต้นจนจบ จากนั้นจึงกล่าวถึงสกิลอีกประเภทหนึ่ง คือสกิลที่อยู่ในแมนิเฟสต์ของปลั๊กอิน

ทักษะสองประเภท

Nexus ใช้คำว่า "สกิล" สำหรับสองสิ่งที่แตกต่างกัน และทั้งสองสิ่งถูกสร้างขึ้นด้วยวิธีที่ต่างกัน

สกิลของ Skills Engine สกิลแมนิเฟสต์
คำอธิบาย แพ็กเกจ SKILL.md ในคลังสกิล แถวที่มีการกำหนดชนิดในอาร์เรย์ skills[] ของปลั๊กอิน
ผู้เขียน ทุกคนที่มีสิทธิ์ ในเครื่องมือสร้างหรือในโปรแกรมแก้ไขของตนเอง นักพัฒนา ภายในปลั๊กอิน
สิ่งที่บรรจุอยู่ คำสั่ง เครื่องมือที่สกิลอาจเรียกใช้ ไฟล์และสคริปต์ที่เป็นทางเลือก สคีมาอินพุตและเอาต์พุต ระดับ (tier) และฟิลด์ที่ระดับนั้นต้องการ
วิธีที่สกิลเข้าสู่แพลตฟอร์ม ตรวจสอบความถูกต้อง อัปโหลด และเผยแพร่ไปยัง Skills Engine คอมไพล์จากแมนิเฟสต์และซิงก์ไปยังรีจิสทรีสกิล
สิ่งที่เรียกใช้สกิล ผู้ช่วย เอเจนต์ เวิร์กโฟลว์ ปุ่ม AI (ปัญญาประดิษฐ์) และ Claude Code การส่งงานของ UNO (เอนจินเวิร์กโฟลว์)
การใช้งานทั่วไป "สรุปแผนท่าเทียบเรือในรูปแบบเดียวกันทุกครั้ง" "รันตัวคำนวณวงโคจรของเราสำหรับรอบโคจรนี้"

เนื้อหาส่วนที่เหลือของบทนี้จะแยกทั้งสองอย่างออกจากกัน หากย่อหน้าใดกล่าวถึง "สกิล" เพียงอย่างเดียว หมายถึงสกิลของ Skills Engine

ส่วนที่ 1: ทักษะของ Skills Engine

สกิลคืออะไร

สกิลคือโฟลเดอร์ SKILL.md ของสกิลระบุว่าสกิลมีไว้เพื่ออะไรและทำงานอย่างไร ข้าง ๆ กันจะมีไฟล์ที่งานนั้นต้องใช้และสคริปต์ที่งานนั้นเรียกใช้ เอนจินโหลดสกิลเป็นสามชั้น ได้แก่ ชื่อและคำอธิบายซึ่งโหลดเสมอ คำสั่งซึ่งโหลดเมื่องานต้องใช้สกิลนั้น และไฟล์ซึ่งโหลดเฉพาะเมื่อขั้นตอนใดต้องใช้ ด้วยเหตุนี้การติดตั้งหนึ่งชุดจึงเก็บสกิลได้สองร้อยสกิลโดยแทบไม่มีต้นทุนจนกว่าจะมีการใช้สกิลใดสกิลหนึ่ง

skills/<slug>/
├── SKILL.md      # required: YAML frontmatter, then the instructions
├── skill.yaml    # optional: engine metadata (triggers, aliases, tags, capabilities)
└── scripts/      # optional: bundled with the skill as components

ชื่อไดเรกทอรีต้องตรงกับ slug ของสกิล หากไม่ตรงกันจะเกิดคำเตือนในการตรวจสอบความถูกต้อง และควรแก้ไข เนื่องจาก slug คือสิ่งที่คลังใช้จับคู่การอัปโหลดกับสกิลที่มีอยู่แล้ว

Frontmatter ของ SKILL.md

Frontmatter คือ YAML ที่อยู่ระหว่างบรรทัด --- สองบรรทัดที่ด้านบนของไฟล์ รูปแบบนี้กำหนดให้มีสามฟิลด์ การตรวจสอบความถูกต้องจะบล็อกเพียงไม่กี่กรณี ได้แก่ ไม่มีชื่อหรือคำอธิบาย และ slug หรือประเภทงานที่ถูกใช้ไปแล้ว ส่วนกรณีอื่นทั้งหมดจะรายงานเป็นคำเตือน

ฟิลด์ ชนิด จำเป็น ข้อมูลที่เก็บ
name string ใช่ ตัวระบุที่ไม่ซ้ำกัน ในรูปแบบ kebab-case
description string ใช่ สิ่งที่สกิลทำ ไม่เกิน 500 อักขระ คลังและตัวจับคู่จะอ่านข้อความนี้ ดังนั้นโปรดเขียนสำหรับผู้อ่านที่กำลังตัดสินใจว่านี่คือสกิลที่ถูกต้องหรือไม่
allowed-tools string หรือ list ใช่ เครื่องมือที่สกิลอาจเรียกใช้ ซึ่งทำได้เพียงจำกัดรายการที่อนุญาตของผู้ที่เรียกใช้ให้แคบลงเท่านั้น
triggers list ไม่ใช่ คำสั่งสแลชที่เรียกใช้สกิลโดยตรง
capabilities list ไม่ใช่ ความสามารถแบบมีโครงสร้าง แต่ละรายการมี name และ description และอาจมี input_schema, output_schema และ examples
version string ไม่ใช่ เวอร์ชันแบบ semantic โดยจะเป็น 1.0.0 เมื่อไม่ได้ระบุ
visibility string ไม่ใช่ private, team หรือ public
status string ไม่ใช่ draft, testing หรือ published

ควรเขียนคำสั่งให้มีความยาวไม่เกินประมาณ 5,000 โทเค็น เขียนให้เจาะจงและยกตัวอย่าง แต่ละสกิลควรทำงานเดียวให้ดี หากคุณพบว่าตนเองเขียนว่า "และยัง" แสดงว่าคุณอาจมีสองสกิล

skill.yaml

skill.yaml เก็บสิ่งที่เอนจินต้องใช้สำหรับการค้นพบและคลัง เพื่อให้ SKILL.md ยังคงอ่านง่าย ฟิลด์ที่เอนจินอ่านได้แก่ name, display_name, description, version, status, visibility, triggers, aliases, category, tags, allowed_tools และ capabilities ความสามารถหนึ่งรายการสามารถมี query_patterns ซึ่งคือรูปประโยคที่ตัวจับคู่ควรส่งมายังความสามารถนั้น นอกจากนี้ยังมีคำแนะนำสำหรับการจัดสรรงบประมาณของเอนจินเอง ได้แก่ complexity, estimated_tokens และ required_services

scripts/

ทุกสิ่งภายใต้ scripts/ จะถูกรวมไปกับสกิลตามต้นฉบับทุกประการในฐานะคอมโพเนนต์ สคริปต์จะถูกรัน ไม่ถูกอ่านเข้าไปในบริบทของโมเดล และรันในแซนด์บ็อกซ์ โปรดใช้สคริปต์เมื่อขั้นตอนใดเป็นการคำนวณหรือการแยกวิเคราะห์ที่โมเดลไม่ควรทำในใจ

การมองเห็นและสถานะ

การมองเห็นระบุว่าใครค้นพบสกิลได้ private คือคุณ team คือทีมของคุณ และ public คือทุกคนในองค์กรที่คลังให้บริการ ในคอนโซล ตัวเลือกเดียวกันนี้แสดงเป็น "เฉพาะฉัน" ทีม เช่น "Customs desk" หรือทั้งองค์กร และสกิลยังสามารถแชร์เข้าไปในโดเมนแพ็กผ่านการตรวจทานของแพ็กนั้นเองได้ด้วย

สถานะระบุว่าสกิลอยู่ในช่วงใดของวงจรชีวิต

สถานะ ความหมาย
draft อยู่ระหว่างดำเนินการ ค้นพบไม่ได้
testing อยู่ระหว่างตรวจสอบความถูกต้อง เข้าถึงได้อย่างจำกัด
published พร้อมใช้งานทั่วไป
deprecated ถูกแทนที่แล้ว และกำลังจะถูกเลิกใช้

เมื่อเผยแพร่เวอร์ชันแล้ว เวอร์ชันนั้นจะไม่เปลี่ยนแปลงอีก ในคอนโซล "live" "canary" และ "shadow" เป็นป้ายกำกับบนเวอร์ชัน และการสลับกลับไปยังเวอร์ชันก่อนหน้าคือการย้ายป้ายกำกับ การรันที่กำลังดำเนินอยู่จะทำงานจนเสร็จบนเวอร์ชันที่เริ่มต้นไว้

สกิลใหม่ · 2 คำสั่งและเครื่องมือ
สกิลใหม่ · 2 คำสั่งและเครื่องมือ
ขั้นตอนที่สองของเครื่องมือสร้างแสดง SKILL.md ฉบับร่าง ไฟล์ที่อยู่ข้าง ๆ และเวลาที่แต่ละไฟล์ถูกโหลด รวมถึงเครื่องมือที่สกิลอาจเรียกใช้ สกิลสำหรับการตรวจสอบจะไม่ได้รับเครื่องมือใดที่เขียนข้อมูล และสกิลทำได้เพียงจำกัดรายการที่อนุญาตของผู้รันให้แคบลงเท่านั้น

จากโฟลเดอร์สู่สกิลที่ใช้งานจริง

สคริปต์ npm ห้าตัวในรีโพสิทอรีของ Skills Engine จะนำสกิลจากโปรแกรมแก้ไขของคุณไปยังคลัง และพิสูจน์ว่าสกิลไปถึงแล้ว

คำสั่ง สิ่งที่ทำ
npm run skill:validate skills/<slug> ตรวจสอบแพ็กเกจ (lint) การเผยแพร่ต้องไม่มีข้อผิดพลาดเลย
npm run skill:upload skills/<slug> ตรวจสอบความถูกต้องและเผยแพร่ในขั้นตอนเดียว เป็นแบบ idempotent
npm run skill:upload skills/<slug> --dry-run ตรวจสอบความถูกต้องและพิมพ์แผนโดยไม่เขียนสิ่งใด
npm run skill:publish -- --dry-run skills/<slug> การเผยแพร่ระดับล่างที่อยู่เบื้องหลังการอัปโหลด ใช้ไปป์ไลน์เดียวกัน
npm run skill:reconcile เปรียบเทียบสกิลในรีโพสิทอรีของคุณกับสิ่งที่คลังและรีจิสทรีสกิลมีอยู่
npm run skill:live:verify ตรวจสอบสกิลที่เผยแพร่แล้วตั้งแต่ต้นจนจบบนการติดตั้งที่กำลังทำงาน

การเผยแพร่จะเขียนรายการสองรายการ และทั้งสองรายการมีความสำคัญ รายการหนึ่งคือตัวสกิลเอง พร้อมเนื้อหา SKILL.md ความสามารถ คอมโพเนนต์ และบันทึกคุณภาพ ซึ่งคลัง การค้นพบ และการจับคู่จะอ่านรายการนี้ อีกรายการหนึ่งคือรายการในรีจิสทรีที่เอนจินเวิร์กโฟลว์ใช้ในการระบุปลายทางของการส่งงาน สกิลที่ไปถึงเพียงรีจิสทรีจะรันได้ แต่จะมองไม่เห็นในคลังจนกว่าคุณจะอัปโหลด

การเผยแพร่เป็นแบบ idempotent สกิลที่ไม่มีการเปลี่ยนแปลงจะไม่มีผลใด ๆ และสกิลที่มีอยู่แล้วจะถูกจับคู่ด้วย slug และอัปเดตในที่เดิม โดยไม่มีการสร้างใหม่ หากคุณอัปโหลดไบต์เดียวกันกับเวอร์ชันที่เผยแพร่แล้ว คุณจะได้รับเวอร์ชันนั้นกลับมาพร้อม CONTENT_HASH_ALREADY_PUBLISHED ไม่ใช่สำเนาซ้ำ

skill:reconcile ไล่ตรวจสกิลในรีโพสิทอรีของคุณเทียบกับคลัง รีจิสทรี และรายการทรัพยากรของเอนจินเวิร์กโฟลว์ และรายงานทุกสิ่งที่มีอยู่ในที่หนึ่งแต่ไม่มีในอีกที่หนึ่ง skill:live:verify ตรวจสอบเพิ่มเติมบนการติดตั้งที่กำลังทำงาน ได้แก่ รายการทั้งสองมีอยู่และชี้ถึงกันด้วยแฮชเนื้อหาเดียวกัน การส่งงานแบบ dry-run ของประเภทงานของสกิลได้รับการยอมรับ สกิลแสดงในรายการและรายละเอียดของคลัง สกิลเรียกใช้ได้ และร่องรอยการตรวจสอบเชื่อมโยงการเผยแพร่ การส่งงาน และการรันเข้าด้วยกันด้วย slug และ request id

จากเวิร์กสเตชัน การอัปโหลดจะไปถึงบริการความรู้ของการติดตั้ง nexus-graphrag ผ่าน port-forward และต้องมีคีย์บริการของ Skills Engine ในสภาพแวดล้อม โปรดโหลดคีย์โดยไม่แสดงค่าออกมา:

kubectl -n nexus port-forward svc/nexus-graphrag 8090:8090
read -rs GRAPHRAG_SKILLS_ENGINE_SERVICE_KEY
export GRAPHRAG_SKILLS_ENGINE_SERVICE_KEY
GRAPHRAG_URL=http://localhost:8090 npm run skill:upload skills/berth-allocation-summary

ภายในคลัสเตอร์ ในงานของไปป์ไลน์ ที่อยู่เริ่มต้นจะระบุได้เองและไม่จำเป็นต้องใช้ GRAPHRAG_URL โปรดขอรับคีย์ผ่านกระบวนการจัดการข้อมูลลับขององค์กรคุณเอง คีย์ต้องไม่อยู่ในรีโพสิทอรี ประวัติเชลล์ หรือเอาต์พุตของคำสั่งใด ๆ

การทดสอบ การอนุมัติ และการเริ่มใช้งานจริง

สกิลจะเข้าสู่คลังในสถานะฉบับร่าง และเครื่องมือสร้างจะคงสกิลไว้ในสถานะนั้นจนกว่าจะผ่านสามสิ่ง

รายการตรวจสอบ สิ่งที่ทำ
กรณีทดสอบ ทุกกรณีต้องผ่านก่อนที่สกิลจะส่งไปขออนุมัติได้ กรณีทดสอบจะถูกลบได้ก็ต่อเมื่อมีเหตุผล ซึ่งผู้อนุมัติจะเห็นเหตุผลนั้น
การทดลองรันในโหมด shadow สกิลจะรันกับงานในอดีตซึ่งไม่มีใครเห็นคำตอบ และผลลัพธ์จะถูกเปรียบเทียบกับสิ่งที่บุคคลได้ตัดสินใจไว้ในเวลานั้น
การตรวจทานแบบปิดโดยโมเดลจากตระกูลอื่น การตรวจทานนี้มองหาการตรวจสอบที่ตกหล่น แหล่งข้อมูลที่ถูกแต่งขึ้น และคำสั่งที่ถูกแฝงไว้ซึ่งสกิลทำตามทั้งที่ไม่ควรทำ

จากนั้นจึงเป็นการอนุมัติ สกิลที่เพิ่มเครื่องมือที่เขียนข้อมูลจะถูกระงับไว้จนกว่าจะมีสองคนอนุมัติด้วยพาสคีย์ของตน และผู้เสนอไม่สามารถเป็นหนึ่งในนั้นได้ (PUBLISH_NEEDS_APPROVAL) จากนั้นสกิลจะเริ่มใช้งานจริงในโหมด shadow ต่อด้วยโหมด canary สำหรับหนึ่งหน่วยงานภายใต้เกณฑ์ที่ระบุชื่อ แล้วจึงสำหรับทุกคน หากไม่ผ่านเกณฑ์ของ canary การทำ canary จะหยุดเองและทุกคนจะยังคงใช้เวอร์ชันก่อนหน้า การส่งไปยังทุกคนก่อนกำหนดต้องมีเหตุผลและผู้อนุมัติคนที่สอง (CANARY_GATE_NOT_MET)

ในรุ่น Community จะมีเครื่องมือสร้าง คลัง เวอร์ชัน และการทดสอบครบทั้งหมด และเจ้าของจะเผยแพร่ได้เพียงลำพังเมื่อการทดสอบผ่าน ส่วน canary การอนุมัติโดยสองคน การซิงก์ปลั๊กอิน และการรวมสกิลที่ซ้ำกันจะมาพร้อมกับรุ่น Enterprise

สกิลใหม่ · 4 เผยแพร่
สกิลใหม่ · 4 เผยแพร่
การเผยแพร่แสดงเหตุผลที่สกิลถูกระงับไว้ ผู้ที่ต้องให้ความเห็นชอบ และวิธีที่สกิลจะเริ่มใช้งานจริง ได้แก่ ได้รับอนุมัติ อยู่ในโหมด shadow อยู่ในโหมด canary ภายใต้เกณฑ์ที่ระบุชื่อ แล้วจึงสำหรับทุกคน ผู้เสนอไม่สามารถอนุมัติการเปลี่ยนแปลงของตนเองได้ และเวอร์ชันล่าสุดก่อนหน้าจะพร้อมให้สลับกลับเสมอ

ตำแหน่งที่สกิลปรากฏ

สกิลที่เผยแพร่แล้วสกิลเดียวกันจะเข้าถึงผู้ใช้ในห้าตำแหน่ง

  1. ผู้ช่วยจับคู่คำขอกับสกิลตามคำอธิบาย ทริกเกอร์ และรูปแบบคำค้นของสกิล และทำตามคำสั่งของสกิล
  2. เอเจนต์และเวิร์กโฟลว์เรียกใช้สกิลเป็นขั้นตอน ขั้นตอนของเวิร์กโฟลว์จะระบุชื่อสกิล และการรันจะบันทึกว่าใช้เวอร์ชันใด
  3. ปุ่ม AIบนหน้าจอแต่ละปุ่มจะรันหนึ่งสกิล ผู้ดูแลระบบสามารถเปิด "เกี่ยวกับปุ่มนี้" เพื่อดูสกิลที่ปุ่มรัน สิ่งที่สกิลอ่าน และผู้ที่แก้ไขล่าสุด และสามารถปิดปุ่มได้โดยไม่กระทบสกิล
  4. IDE (สภาพแวดล้อมการพัฒนาแบบเบ็ดเสร็จ) ของคุณและ Claude Codeเข้าถึงคลังผ่าน Workbench และเครื่องมือ MCP (Model Context Protocol) สิบสามรายการ ซึ่งรวมถึง list_skills, get_skill, match_prompt, discover_skills, invoke_skill, record_execution, create_skill, import_skill, get_generation_job และ sync_skills_local การเรียกแต่ละครั้งจะรันในนามของผู้ที่เริ่มการเรียก ภายในรายการที่อนุญาตของบุคคลนั้น
  5. คลังสกิลเอง ซึ่งผู้ใช้เรียกดู รัน และเสนอการเปลี่ยนแปลงสกิลได้ และผู้ดูแลระบบจะเห็นเจ้าของ ผู้ใช้ การรัน และค่าใช้จ่ายของแต่ละสกิล

ไม่ว่าสิ่งใดจะรันสกิล สกิลก็ไม่สามารถขยายสิ่งที่ผู้รันได้รับอนุญาตให้ทำได้ สกิลจะเรียกใช้เฉพาะเครื่องมือภายในรายการที่อนุญาตของผู้รัน และอ่านเฉพาะสิ่งที่บุคคลนั้นมีสิทธิ์เปิด (SKILL_CANNOT_WIDEN_TOOLS) การรันที่ไม่มีเส้นทางโมเดลจะถูกปฏิเสธแทนการคาดเดา (SKILLS_ENGINE_BINDING_MISSING) โดยตัวส่งงานจะเลือกเส้นทางจากการตั้งค่าโมเดลขององค์กรเอง

เกี่ยวกับปุ่มนี้
เกี่ยวกับปุ่มนี้
เกี่ยวกับปุ่มนี้แสดงสกิลที่ปุ่ม AI รัน แหล่งข้อมูลสามแหล่งที่สกิลอ่าน ผู้เขียนและผู้ตรวจทาน และสิ่งที่เวอร์ชันล่าสุดเปลี่ยนแปลง การปิดปุ่มจะนำปุ่มออกจากทุกที่พร้อมกัน โดยสกิลและคำตอบในอดีตทั้งหมดยังคงอยู่

ตัวอย่างการใช้งาน: สรุปการจัดสรรท่าเทียบเรือสำหรับ Harrow

ผู้วางแผนของ Harrow มีเครื่องมือแบบอ่านอย่างเดียวสองรายการในรายการที่อนุญาตอยู่แล้ว จากปลั๊กอินวางแผนท่าเทียบเรือของ Harrow เอง ได้แก่ berth-plan.read ซึ่งส่งคืนแผนของวันที่ที่ระบุ และ vessel-call.read ซึ่งส่งคืนการเข้าเทียบท่าของเรือพร้อมช่วงเวลาที่มาถึงและความยาวของเรือ สกิลไม่ต้องการสิ่งอื่นใด สกิลไม่เคยเขียนข้อมูล จึงไม่ต้องมีผู้อนุมัติสองคน

---
name: berth-allocation-summary
description: Summarise tomorrow's berth plan at Harrow for the planning desk. Use when someone asks who is on which berth, what moved since the last plan, or where two calls clash.
allowed-tools: berth-plan.read, vessel-call.read
triggers:
  - /berth-summary
capabilities:
  - name: summarise_berth_plan
    description: The berth table, the changes since the last plan and any clashes, for one date
version: 1.0.0
visibility: team
status: draft
---

# Berth allocation summary

## When to use
A planner asks about the berth plan for a date, or asks what changed.

## Steps
1. Read the plan for the date with berth-plan.read. If no date is given, use tomorrow.
2. For each call on the plan, read it with vessel-call.read.
3. Write the berth table first: berth, vessel, arrival window, length overall.
4. Then list what moved since the previous plan, one line per change, with the reason the plan records.
5. Then list clashes: two calls whose windows overlap on one berth, or a vessel longer than the berth.
6. Cite the plan's version for every line. Never guess a time the plan doesn't give.

## Output
Three headed sections, in this order: Berths, Changes, Clashes. Write "No clashes" when there are none.

skill.yaml ที่อยู่ข้าง ๆ ให้ชื่อที่แสดง หมวดหมู่ และรูปประโยคที่ตัวจับคู่ควรส่งมายังสกิลนี้แก่คลัง:

# skill.yaml, beside SKILL.md
name: berth-allocation-summary
display_name: "Berth allocation summary"
version: "1.0.0"
status: draft
visibility: team
category: operations
tags:
  - berths
  - planning
triggers:
  - "/berth-summary"
allowed_tools:
  - berth-plan.read
  - vessel-call.read
capabilities:
  - name: "summarise_berth_plan"
    description: "Berth table, changes since the last plan and clashes, for one date"
    query_patterns:
      - "who is on which berth tomorrow"
      - "what moved on the berth plan"
      - "any berth clashes on *"

จากนั้นจึงเป็นคำสั่ง จากรากของรีโพสิทอรี:

npm run skill:validate skills/berth-allocation-summary
npm run skill:upload skills/berth-allocation-summary --dry-run
npm run skill:upload skills/berth-allocation-summary

Tomás เพิ่มกรณีทดสอบหกกรณีในเครื่องมือสร้าง ได้แก่ วันปกติ วันที่มีเรือมาถึงล่าช้าจนทำให้การเข้าเทียบท่าสองรายการต้องเลื่อน วันที่มีข้อขัดแย้งจริง วันที่ยังไม่มีแผน เรือที่ยาวเกินกว่าท่าเทียบเรือ และคำขอที่พยายามให้สกิลเสนอท่าเทียบเรือใหม่ (ซึ่งสกิลไม่ควรทำ เพราะไม่มีเครื่องมือที่เขียนข้อมูล) การทดลองรันได้เล่นซ้ำแผนในอดีตยี่สิบแผนในโหมด shadow เมื่อกรณีทดสอบผ่านแล้ว ผู้ตรวจทานจากฝ่ายวางแผนได้อนุมัติ และสกิลก็เริ่มใช้งานจริงสำหรับทีมวางแผน ปัจจุบันผู้ช่วยตอบคำถามนี้ในรูปแบบเดียวกันทุกครั้ง และปุ่ม AI ของผู้วางแผนบนหน้าแผนท่าเทียบเรือก็รันสกิลเดียวกัน

ส่วนที่ 2: ทักษะใน Manifest

สกิลแมนิเฟสต์คือหน่วยการประมวลผลที่ปลั๊กอินเผยแพร่ โดยประกาศไว้ใน skills[] ของแมนิเฟสต์ ตรวจสอบความถูกต้องโดย SDK (ชุดพัฒนาซอฟต์แวร์) เมื่อคุณรัน create-nexus-plugin validate คอมไพล์เป็นเนื้อหาของรีจิสทรีโดย compileRegistry และซิงก์ไปยังรีจิสทรีสกิล คุณไม่ต้องเขียน SQL ของรีจิสทรีด้วยตนเอง ดังนั้นแถวที่แพลตฟอร์มส่งงานและตัวอธิบายที่คุณประกาศไว้จึงไม่มีทางคลาดเคลื่อนจากกัน

สกิลแมนิเฟสต์ทุกสกิลต้องมี id, displayName, description, tier, classification, inputSchema และ outputSchema โปรดประกาศ timeoutMs ด้วย ซึ่งเป็นจำนวนเต็มตั้งแต่ 1,000 ถึง 21,600,000 (หนึ่งวินาทีถึงหกชั่วโมง) และค่าที่อยู่นอกช่วงดังกล่าวจะถูกปฏิเสธด้วย TIMEOUT_OUT_OF_BOUNDS dataResidency มีค่าเป็น any, eu หรือ us และ any เป็นค่าเริ่มต้น

id เป็นแบบ lower_snake และคีย์การส่งงานของรีจิสทรีคือประเภทงานที่มีเนมสเปซ <plugin name>.<skill id> ดังนั้นปลั๊กอินสองตัวจึงสามารถมีสกิล summarise ได้ทั้งคู่โดยไม่ชนกัน ต่อไปนี้คือสกิลเดียวของเทมเพลตซึ่งตัดทอนแล้ว:

{
  "id": "sentiment_score",
  "displayName": "Sentiment score",
  "description": "Deterministic lexicon-based sentiment score for a piece of text.",
  "tier": "host_callback",
  "classification": "tenant",
  "dataResidency": "any",
  "inputSchema": { "type": "object", "properties": { "text": { "type": "string", "minLength": 1 } }, "required": ["text"] },
  "outputSchema": { "type": "object", "properties": { "score": { "type": "number" } }, "required": ["score"] },
  "hostCallback": {
    "service": "my-plugin",
    "port": 8080,
    "path": "/internal/skills/sentiment_score",
    "maxRequestBytes": 262144,
    "maxResponseBytes": 16384,
    "tenantHeader": "X-Organization-ID"
  },
  "timeoutMs": 10000
}

ห้าระดับ

ระดับไม่ใช่เพียงป้ายกำกับ แต่ละระดับมีฟิลด์เป็นของตนเอง และฟิลด์ที่เป็นของระดับอื่นจะถูกปฏิเสธด้วย FIELD_NOT_FOR_TIER แทนที่จะถูกทิ้งไปอย่างเงียบ ๆ

ระดับ สิ่งที่ต้องมี เข้าถึงโมเดล ผู้รัน
host_callback hostCallback: Service ของคุณ พอร์ตของ Service นั้น พาธ และขีดจำกัดไบต์ทั้งสองค่า ไม่ แพลตฟอร์ม POST อินพุตไปยัง Service ของคุณเอง ภายในเนมสเปซของคุณ
plugin_queue queueName ซึ่งเขียนว่า <plugin name>.<name> ไม่ เวิร์กเกอร์ของคุณ ซึ่งดึงงานจากคิวของคุณ
tool_using systemPrompt และ tools[]; ระดับความเชื่อถือ core หรือ verified ได้ แพลตฟอร์ม ผ่าน AI Provider Router; การเรียกเครื่องมือแต่ละครั้งทำงานผ่านตัวดำเนินการที่อยู่ในรายการที่อนุญาต
llm_only systemPrompt; ระดับความเชื่อถือ core หรือ verified ได้ แพลตฟอร์ม เรียกหนึ่งครั้งผ่าน AI Provider Router
map map.perItemJobType โดยระบุชื่อสกิลอื่นในแมนิเฟสต์เดียวกันที่ไม่ใช่ map ผ่านเป้าหมายของมันเท่านั้น แพลตฟอร์มรันเป้าหมายหนึ่งครั้งต่อหนึ่งรายการและรวบรวมผลลัพธ์

ระดับโมเดลทั้งสองไม่ได้ระบุผู้ให้บริการหรือโมเดล ตัวเราเตอร์จะเลือกทั้งสองอย่างจากพูลขององค์กรที่ส่งงานเอง เครื่องมือในสกิล tool_using ระบุตัวดำเนินการหนึ่งในหกตัว ได้แก่ standing_service_call (Service ของคุณเอง), graphrag, graphrag_query, graphrag_search, h3 หรือ web_search ตัวอื่นใดจะถูกปฏิเสธด้วย EXECUTOR_NOT_PERMITTED ตัวดำเนินการกราฟความรู้ทั้งสามตัวยอมรับเฉพาะชื่อเครื่องมือ graphrag_query และ graphrag_search เนื่องจากตัวดำเนินการจะรันการดำเนินการใดก็ตามที่ตรงกับชื่อของเครื่องมือ

มีสองระดับในรีจิสทรีที่ปลั๊กอินไม่สามารถประกาศได้ นั่นคือ เชนและสกิลที่ทำงานด้วยตัวเองจะถูกเขียนโดยแพลตฟอร์มเท่านั้น การซิงก์ที่ระบุระดับเหล่านี้จะถูกปฏิเสธทั้งหมด

ควรใช้ระดับใด

  • ใช้ host_callback เมื่องานเป็นฟังก์ชันของอินพุตที่โค้ดของคุณเองคำนวณ เช่น คะแนน การคำนวณ หรือการค้นหาในสคีมาของคุณเอง ระดับนี้ทดสอบได้ง่ายที่สุดและเป็นค่าเริ่มต้นของเทมเพลต ปกป้องเส้นทางคอลแบ็ก: พาธในแมนิเฟสต์ไม่ใช่ความลับ และเส้นทางต้องตรวจสอบการเรียกของแพลตฟอร์มและรับองค์กรจากการเรียกนั้น ห้ามรับจากเนื้อหาคำขอ ประกาศเป็น auth: internal และติดตั้ง requireService (Fastify) หรือ serviceMiddleware (Express) บนเส้นทางนั้น ตัวป้องกันจะปฏิเสธโทเค็นที่ออกให้ผู้อื่น ตอบกลับอย่างรวดเร็ว และทำให้การส่งงานเดียวกันซ้ำเป็นครั้งที่สองไม่ก่อผลเสีย
  • ใช้ plugin_queue สำหรับงานที่ยาวกว่าซึ่งมีผู้ใช้รออยู่ โดยที่เวิร์กเกอร์ของคุณเป็นผู้ดูแลวงจรชีวิต เวิร์กเกอร์ต้องเปลี่ยนสถานะการรันเป็น running เมื่อเริ่มต้น และเปลี่ยนเป็นสถานะสิ้นสุดเมื่อเสร็จ เวิร์กเกอร์ที่เพียงโพสต์ผลลัพธ์จะทำให้การรันแสดงเป็น queued ตลอดไป
  • ใช้ llm_only เมื่อการเรียกโมเดลหนึ่งครั้งด้วยพรอมต์ระบบที่กำหนดตายตัวทำงานได้ครบ และปลั๊กอินของคุณเป็น core หรือ verified
  • ใช้ tool_using เมื่อโมเดลต้องเรียกเครื่องมือแบบวนซ้ำ ซึ่งก็ใช้ได้เฉพาะที่ core หรือ verified เช่นกัน
  • ใช้ map เมื่อคุณต้องการให้แพลตฟอร์มกระจายสกิลอื่นของคุณสกิลหนึ่งไปทำงานกับรายการ

สกิลการคำนวณวงโคจรของฉันที่ Corrán Orbital เป็น host_callback ปลั๊กอินของเราเป็น community ดังนั้นระดับโมเดลจึงไม่เคยเป็นตัวเลือก และฉันก็ไม่เสียดาย ตัวคำนวณวงโคจรที่ให้คำตอบต่างออกไปในวันอังคารจะแย่ยิ่งกว่าไร้ประโยชน์

การอนุมัติก่อนการรันทุกครั้ง

สกิลในแมนิเฟสต์ที่ต้องไม่ทำงานเพียงเพราะเครื่องสั่งการเท่านั้นจะประกาศดังนี้:

"approval": { "required": true, "reason": "Re-planning a pass needs the flight dynamics lead." }

required เป็น true เสมอ สกิลที่ไม่ต้องการการอนุมัติจะละบล็อกนี้ไว้ reason คือสิ่งที่ผู้อนุมัติเห็น มีความยาว 1 ถึง 500 อักขระหลังตัดช่องว่าง และรูปแบบอื่นใดจะถูกปฏิเสธด้วย APPROVAL_INVALID จากนั้นการส่งงานของสกิลจะถูกพักไว้ โดยการส่งงานจะตอบกลับ 202 พร้อม status: "awaiting_approval" และ waitpointId และมีเพียงการอนุมัติของบุคคลที่ระบุชื่อเท่านั้นที่ปล่อยงานได้ หนึ่งครั้ง การส่งงานแบบ batch, map หรือ chain ของสกิลที่ถูกพักจะถูกปฏิเสธด้วย SKILL_APPROVAL_NOT_HOLDABLE เนื่องจากการกระจายงานไม่สามารถพักรายการของตนได้ ให้แสดงคำตอบที่ถูกพักและให้ผู้อนุมัติตัดสิน อย่าส่งงานก่อนแล้วจึงขอความยินยอม

การซิงก์ไปยังรีจิสทรี

การซิงก์ทุกครั้งเป็นแบบประกาศและถูกตรวจสอบทั้งหมด ให้ส่งชุดสกิลทั้งหมดทุกครั้ง สกิลที่คุณไม่ได้ใส่จะถูกปิดใช้งาน และประวัติการรันของสกิลนั้นยังคงอยู่ สกิลที่ไม่ถูกต้องเพียงหนึ่งสกิลจะทำให้การซิงก์ทั้งหมดถูกปฏิเสธด้วย SYNC_CONTRACT_VIOLATION โดยแสดงการละเมิดทุกรายการพร้อมกันและไม่มีการเขียนสิ่งใด ดังนั้นปลั๊กอินจะไม่ถูกอัปเดตเพียงครึ่งเดียว บทที่ 2.22 รันไทม์ของปลั๊กอิน อธิบายการเรียกซิงก์และวิธีที่แพลตฟอร์มทราบว่าปลั๊กอินใดกำลังเรียก

สกิลใน IDE และ Claude Code
ทักษะใน IDE และ Claude Code
สกิลใน IDE และ Claude Code แสดงขั้นตอนการตรวจสอบ อัปโหลด และเผยแพร่แบบเดียวกันจากเทอร์มินัลของนักพัฒนาเอง โดยฉบับร่างถูกพักไว้เพื่อรอการอนุมัติ เนื่องจากผู้เขียนไม่สามารถอนุมัติการเปลี่ยนแปลงของตนเองได้

การเลือกระหว่างทักษะสองประเภท

หากงานคือ "พูดสิ่งนี้แบบเดียวกันทุกครั้ง" ก็เป็นสกิลของ Skills Engine หากงานคือ "รันโค้ดของฉันและให้คำตอบจากโค้ดนั้น" ก็เป็นสกิลในแมนิเฟสต์ งานจริงส่วนใหญ่กลายเป็นทั้งสองอย่าง: สรุปท่าเทียบเรือของ Harrow เป็นสกิลของ Skills Engine ที่มีเครื่องมือมาจากปลั๊กอิน และเครื่องมือของปลั๊กอินเองก็ประกาศไว้ในแมนิเฟสต์ของปลั๊กอิน สกิลของ Skills Engine เปลี่ยนแปลงได้ถูกกว่าในสองแบบนี้ ซึ่งเป็นเหตุผลที่ดีที่จะเก็บถ้อยคำและการใช้วิจารณญาณไว้ที่นั่น และเก็บการคำนวณไว้ในปลั๊กอิน

ต้นทุนมีอยู่จริงไม่ว่าแบบใด สกิลของ Skills Engine ไม่ได้เสร็จเมื่อ SKILL.md อ่านได้ดี แต่เสร็จเมื่อกรณีทดสอบผ่าน การทดลองรันสอดคล้องกับสิ่งที่ผู้คนตัดสินใจ และมีผู้ที่ไม่ใช่คุณอนุมัติแล้ว เผื่อเวลาหนึ่งสัปดาห์สำหรับสกิลที่เขียนข้อมูล โดยส่วนใหญ่เป็นช่วง canary