ปลั๊กอิน fast-jev-compaction เข้ามาเปลี่ยนวิธีจัดการประวัติการคุยของโปรแกรมช่วยเขียนโค้ดอย่าง Claude Code เมื่อทำงานไปนานจนบทสนทนายาวเกินไป แทนที่จะให้โมเดลเขียนสรุปย่อประวัติเหมือนเดิม ปลั๊กอินตัวนี้จะเลือกลบเฉพาะข้อมูลส่วนที่ไม่ได้ใช้แล้วออกไป

ปกติแล้วการทำงานใน Claude Code จะมีขีดจำกัดความยาวประวัติการสนทนาที่เรียกว่า context window เมื่อบทสนทนายาวจนใกล้ชนเพดาน Claude Code จะย่อประวัติด้วยกระบวนการ compact โดยให้โมเดลอ่านข้อความเก่าทั้งหมดแล้วเขียนสรุปสั้นๆ มาวางแทนที่ เราจะพิมพ์สั่งเองด้วยคำสั่ง /compact หรือปล่อยให้ระบบทำอัตโนมัติก็ได้

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

fast-jev-compaction จึงแก้ปัญหานี้ด้วยการใช้ Jev โมเดล AI จากผู้พัฒนา TypeSafe AI มาอ่านประวัติการสนทนาทั้งหมด แล้วประเมินคะแนน tool call แต่ละครั้ง ถ้า Jev มองว่าครั้งไหนไม่จำเป็นแล้วก็จะลบทิ้งไป ส่วนเนื้อหาที่เหลือจะยังคงอยู่ครบถ้วนทุกคำตามลำดับเดิม โดยโปรเจกต์นี้เปิดเป็นโอเพ่นซอร์สบน GitHub และมีคนกดดาวให้แล้วกว่า 6.7k ดาว

เลือกลบเฉพาะ Tool Call กับผลลัพธ์ที่ส่งกลับมา

ทุกครั้งที่ Claude Code ทำงาน ทั้งการเปิดไฟล์ รันคำสั่งในเทอร์มินัล หรือค้นหาโค้ด ประวัติการทำงานจะบันทึกข้อมูลเพิ่มขึ้นมาเป็นคู่เสมอ

ส่วนแรกคือ tool call ที่ระบุว่า Claude เรียกใช้เครื่องมืออะไรพร้อมข้อมูลนำเข้าแบบไหน เช่น ใช้คำสั่ง Read เพื่อเปิดไฟล์ src/a.ts และส่วนที่สองคือ tool result หรือผลลัพธ์ที่เครื่องมือนั้นส่งกลับมา ซึ่งในตัวอย่างนี้ก็คือเนื้อหาทั้งหมดในไฟล์ โดยปลั๊กอินจะจับคู่ข้อมูลทั้งสองส่วนนี้เข้าด้วยกันผ่าน tool_use_id

จุดสำคัญคือ tool call และ tool result ไม่จำเป็นต้องเก็บหรือลบไปพร้อมกันเสมอไป Jev อาจเลือกเก็บ call เอาไว้ แต่ลบ result ทิ้ง ทำให้ Claude ยังจำได้ว่าเคยเปิดไฟล์นี้ไปแล้ว โดยไม่ต้องแบกเนื้อหาไฟล์ทั้งหมดไว้ในประวัติการสนทนา

ข้อมูลที่ปลั๊กอินจะไม่แตะต้องเลยมีอยู่ 3 ส่วน:

• ข้อความทั้งหมดที่เราพิมพ์และข้อความที่ Claude ตอบกลับ ปลั๊กอินจะไม่ลบ ไม่ย่อ และคงลำดับเดิมไว้ครบทุกคำ
• tool call ที่อยู่ในข้อความแรกสุดของรอบการทำงานนั้น
• tool call ใน 6 ข้อความล่าสุด ตามค่าเริ่มต้นของ preserveRecentMessages เพื่อให้งานที่กำลังทำอยู่ไม่ได้รับผลกระทบ

Jev ประเมิน Tool Call แต่ละตัวด้วยคำถาม 2 ข้อ

ส่วน tool call ที่เหลือทั้งหมด Jev จะประเมินด้วยคำถามแบบใช่/ไม่ใช่ สองข้อ:

1. คำสั่ง call ยังจำเป็นต้องอยู่ต่อไหม? เพื่อดูว่างานปัจจุบันยังต้องรู้อยู่ไหมว่าเคยเรียกใช้เครื่องมือนี้ด้วยข้อมูลนำเข้าชุดนี้
2. ผลลัพธ์ result ยังต้องเก็บไว้ครบทุกคำไหม? เพื่อดูว่ายังต้องใช้เนื้อหาที่ได้กลับมาต่อจริงไหม และเรียกเครื่องมือซ้ำเพื่อดึงข้อมูลเดิมกลับมาได้ง่ายๆ หรือเปล่า

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

Jev จะส่งคำตอบกลับมาเป็นคะแนนความน่าจะเป็น จากนั้นปลั๊กอินจะนำคะแนนไปเทียบกับเกณฑ์ตัดสิน keepThreshold ซึ่งตั้งค่าเริ่มต้นไว้ที่ 0.5 โดยผลลัพธ์จะออกมาได้ 3 รูปแบบ:

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

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

วิธีที่ Jev อ่านประวัติทั้ง Session ผ่านฉบับย่อ

หลายคนอาจสงสัยว่า ในเมื่อประวัติการคุยยาวจนใกล้เต็ม context window แล้ว Jev จะอ่านประวัติทั้งหมดเพื่อมาตัดสินใจได้อย่างไร?

คำตอบคือ ปลั๊กอินจะสร้าง "ประวัติฉบับย่อ" ส่งไปให้ Jev อ่านแทน ฉบับนี้ยังคงมีข้อความทั้งหมดตั้งแต่เริ่มต้นเรียงตามลำดับเดิม แต่จะเปลี่ยนเนื้อหาของ tool result ทุกตัวให้เหลือเพียงหมายเหตุสั้นๆ ที่บอกแค่ความยาวของข้อมูล เช่น ok, 4213 chars (omitted) ส่วนข้อมูลนำเข้าของเครื่องมือและข้อความสนทนาก็ยังส่งไปครบถ้วน โดยไม่มีการสรุปความใดๆ

นอกจากนี้ Jev ยังได้ข้อมูลด้วยว่างานปัจจุบันคืออะไร โดยค่าเริ่มต้นจะดึงมาจาก prompt 3 ข้อความล่าสุดที่เราพิมพ์ เพื่อให้ Jev มีบริบทไว้เทียบว่าข้อมูลส่วนไหนยังเกี่ยวข้องกับงานที่กำลังทำอยู่

ประวัติฉบับย่อนี้ต้องมีขนาดไม่เกิน 25k token ซึ่งเป็นหน่วยนับปริมาณข้อความของโมเดล ถ้ายังยาวเกิน ปลั๊กอินจะค่อยๆ บีบอัดข้อมูลทีละขั้น และจะขยับไปขั้นถัดไปก็ต่อเมื่อขั้นก่อนหน้ายังลดขนาดได้ไม่พอ:

• ขั้นแรก: ตัดทอนข้อมูลนำเข้าของเครื่องมือให้สั้นลงเหลือ 1,000, 200 และ 60 ตัวอักษรตามลำดับ
• ขั้นถัดมา: ย่อข้อความที่ยาวเกินไปให้เหลือเฉพาะส่วนต้นกับส่วนท้าย โดยเริ่มทำจากข้อความที่เก่าที่สุดก่อน
• ขั้นสุดท้าย: ยุบข้อมูลเก่าลงไปอีก เช่น ย่อ tool call เก่าๆ ให้เหลือเพียงบรรทัดเดียวหน้าตาแบบ t12 Read file_path=src/a.ts → ok 480ch

ถ้าบีบอัดครบทุกขั้นแล้วขนาดยังเกินอยู่ การ compact รอบนั้นจะหยุดทันทีพร้อมแจ้งข้อผิดพลาด

ข้อสำคัญที่ต้องเข้าใจตรงกันคือ การบีบอัดข้อมูลทั้งหมดนี้เกิดขึ้นเฉพาะกับ "สำเนา" ที่ส่งให้ Jev อ่านเพื่อตัดสินใจเท่านั้น ประวัติการทำงานจริงที่ Claude นำไปใช้ต่อไม่ได้ย่อตามไปด้วย ข้อความที่เราคุยและข้อความตอบกลับของ Claude ยังคงสมบูรณ์ครบถ้วนทุกคำเหมือนเดิม

สำหรับการส่งคำถาม ปลั๊กอินสามารถแบ่งส่ง request ไปยัง Jev ได้หลายรอบตามความจำเป็น โดยแต่ละรอบจะมีประวัติฉบับย่อรวมกับชุดคำถามไม่เกิน 30k token ซึ่งยังไม่เกินเพดาน 32k token ต่อ request ของโมเดล Jev เอง ทุก request จะแนบประวัติฉบับย่อชุดเดียวกันนี้ ส่งออกไปพร้อมกัน แล้วจึงรวบรวมคำตอบทั้งหมดกลับมา

วิธีติดตั้งและตั้งค่าให้ /compact ส่งงานให้ Jev ก่อน

fast-jev-compaction ทำงานผ่านระบบ function hooks ที่เป็นฟีเจอร์ของ Claude Code เปิดให้ปลั๊กอินเข้าไปแทรกกระบวนการทำงานภายในได้ โดยฟีเจอร์นี้ยังเป็นรุ่นทดลองแบบ Early Access ที่ต้องเปิดใช้งานเอง รองรับใน Claude Code เวอร์ชัน 2.1.274 ขึ้นไป และต้องตั้งค่า environment variable ชื่อ CLAUDE_CODE_ENABLE_FUNCTION_HOOKS ในทุกที่ที่รันโปรแกรม

เราสามารถใส่การตั้งค่านี้ไว้ในไฟล์ ~/.claude/settings.json ควบคู่กับ API Key ของ TypeSafe ได้เลย:

{ "env": { "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS": "1", "TYPESAFE_API_KEY": "<your key>" } }

จากนั้นเพิ่มโปรเจกต์นี้เข้าสู่ Marketplace ของ Claude Code แล้วสั่งติดตั้งผ่านเทอร์มินัลด้วยคำสั่ง 2 บรรทัดนี้:

claude plugin marketplace add tamaratran/fast-jev-compaction
claude plugin install fast-jev-compaction@fast-jev-compaction

ระหว่างการติดตั้ง ระบบจะมีคำถามให้ตั้งค่าตัวเลือกต่างๆ เช่น API Key และเกณฑ์คะแนน ถ้าเราปล่อยว่างไว้ตามค่าเริ่มต้น ปลั๊กอินจะดึงค่าจาก TYPESAFE_API_KEY ที่เราใส่ไว้ใน settings.json มาใช้ให้อัตโนมัติ

เมื่อติดตั้งเสร็จแล้ว ให้รีสตาร์ต Claude Code หรือพิมพ์คำสั่ง /reload-plugins ในหน้าต่างทำงานเดิม หลังจากนี้ ไม่ว่าจะสั่ง /compact เอง หรือปล่อยให้ compact อัตโนมัติ ระบบจะส่งข้อมูลไปให้ Jev ประเมินก่อนเสมอ

ถ้าอยากรู้ว่า compact รอบนั้นทำงานสำเร็จตามที่ตั้งไว้หรือไม่ ให้ดูข้อความแจ้งเตือนที่ขึ้นมาหลัง compact:

fast-jev-compaction: kept N/M messages, no summary (…)

ข้อความนี้หมายความว่า รอบนั้นระบบใช้ประวัติที่ตัดทอนแล้วแทนการเขียนสรุป โดยเก็บไว้ N ข้อความ จากทั้งหมด M ข้อความ

แต่ถ้าข้อความแจ้งเตือนขึ้นว่า fallback to built-in summary แสดงว่าลบข้อมูลออกได้ไม่มากพอ หรือเกิดข้อผิดพลาดขึ้น ปลั๊กอินจึงสลับกลับไปใช้การสรุปย่อแบบเดิมของ Claude Code ทำให้รอบนั้นยังเสี่ยงที่รายละเอียดสำคัญจะตกหล่นเหมือนเดิม กรณีนี้มักเกิดขึ้นกับรอบการทำงานที่ยังสั้น เพราะยังมี tool call ให้เลือกตัดไม่มากพอ

ตัวเลือกหนึ่งที่ควรพิจารณาให้ดีตอนติดตั้งคือค่า keepThreshold:

• ถ้าตั้งไว้ สูงกว่า 0.5: tool call จะต้องได้คะแนนสูงขึ้นจึงจะได้อยู่ต่อ ช่วยให้ประวัติสั้นลงและประหยัดพื้นที่ context window ได้มากขึ้น แต่ Claude ก็มีโอกาสต้องเรียกใช้เครื่องมือซ้ำบ่อยขึ้น เพื่อดึงข้อมูลที่ลบไปกลับมา
• ถ้าตั้งไว้ ต่ำกว่า 0.5: ปลั๊กอินจะเก็บข้อมูลไว้มากขึ้น แลกกับประวัติที่ลดขนาดลงได้น้อยกว่า

ดูวิธีตั้งค่าเพิ่มเติมได้ใน hooks/README.md ของโปรเจกต์

สำหรับใครที่อยากทดลองใช้งานก่อนติดตั้งจริง สามารถ clone โปรเจกต์ลงมาในเครื่อง แล้วสั่งรันด้วย CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude --plugin-dir . หรือถ้าต้องการนำกลไกนี้ไปใช้ในเครื่องมือของตัวเอง ก็ติดตั้งเป็นไลบรารีได้ด้วยคำสั่ง npm install fast-jev-compaction

ข้อจำกัดและสิ่งที่ต้องแลกกับการไม่สรุป

แม้ระบบจะประเมินด้วยคะแนนความน่าจะเป็น แต่ผู้พัฒนาเองก็ระบุเตือนไว้ชัดเจนในหน้าโปรเจกต์ว่า คะแนนนี้ไม่ได้เป็นหลักประกัน 100% ว่าผลลัพธ์ result ชิ้นนั้นจะลบทิ้งได้อย่างปลอดภัย แต่แนวทางแก้ไขที่เตรียมไว้คือ Claude สามารถสั่งรันเครื่องมือซ้ำได้เสมอ ถ้าเนื้อหาไฟล์ที่ลบไปจำเป็นต้องใช้อีกครั้ง โมเดลก็แค่สั่งเปิดอ่านใหม่ แลกกับการเสียเวลาเรียกคำสั่งเดิมซ้ำอีกรอบ

อีกเรื่องที่ต้องแลกมาคือจำนวน API request ที่เพิ่มขึ้น เพราะทุก request จำเป็นต้องแนบประวัติฉบับย่อทั้งก้อนไปด้วย ถ้าประวัติการคุยยาวจนเกือบชนเพดาน 25k token แต่ละ request จะใส่คำถามประเมินได้เพียงไม่กี่ข้อเท่านั้น

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

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

อย่างไรก็ดี ข้อดีสำคัญคือ ข้อมูลของเครื่องมือที่ลบทิ้งไป Claude สามารถสั่งรันใหม่เพื่อเอากลับคืนมาได้เสมอ ต่างจากการสรุปความแบบเดิมที่ถ้ารายละเอียดสำคัญหล่นหายไป เราอาจไม่รู้ตัวด้วยซ้ำว่ามีอะไรตกหล่นไปบ้าง

ที่มา: โปรเจกต์ fast-jev-compaction บน GitHub