claude-code-token-saver

התוסף היחיד ל-Claude Code שקורא בפועל את קוד המקור של CC כדי למצוא לאן הטוקנים שלך הולכים — ומתקן את זה אוטומטית. תוציא פחות, תכתוב קוד יותר.

תוצאה מדודה: הפחתת עלויות של 45% על עומס עבודה אמיתי של $326/יום → $180/יום. מניעת פקיעת cache, האצלת SubTask אוטומטית, שחזור context ללא עלות, ולוח אנליטיקה מלא — בהתקנה אחת, ללא הגדרה.

עובד עם Max Plan ($200/חודש) ו-API לפי שימוש. אותו תוסף, אותן תכונות. חזק יותר לכל משתמש — במיוחד כשכל טוקן הוא כסף אמיתי.

מה הוא עושה תוך 30 שניות

תכונה	מה קורה	השפעה
🛡️ Token Guardian	מזהה פקיעת cache, חוסם שליחות חוזרות של $9 לפני שהן קורות	מונע את עלייה השקטה מספר 1 בעלויות
🧠 Session Architect	מאציל עבודה כבדה לSubTasks אוטומטית (37.5% cache זול יותר)	Context נשאר קטן, עלויות יורדות
🪶 Concise Mode	מקצץ ריפוד בתשובות, שומר על המהות	פחות טוקני פלט לתשובה
🔄 /cc-continue	מחליף את /compact — אפס קריאות LLM, אפס עלות, אפס אובדן מידע	שחזור context בחינם
🤝 /cc-compact	כותב מסמך מסירת סשן ש-/cc-continue טוען אוטומטית — לוכד ממצאי sub-agent ותוצאות כלים שה-transcript מאבד	הסשן הבא ממשיך גם עם ה-context הנסתר
📊 Status Line	עלות בזמן אמת, גודל context, מגבלת קצב — מתחת ל-50ms	ראה בעיות לפני שהן עולות לך
📈 /usage-view	לוח HTML אינטראקטיבי עם ניתוח AI	בלשות עלויות מלאה בלחיצה אחת
✂️ /setup-git-lite	מסיר 2,200 טוקנים נסתרים ש-CC מזריק בכל סשן	~$48/חודש חסכון רק על הוראות git

😤 הבעיה

פקיעת cache. אתה חוזר מארוחת הצהריים. ה-cache נעלם. prompt אחד שולח מחדש 900K טוקנים במחיר מלא. $9 בצעד אחד.

עלויות בלתי נראות. אין נראות בזמן אמת. אין אזהרה "ה-context שלך ב-800K". אין התראה "ה-cache פג לפני 3 דקות". אתה מגלה לאחר שהנזק נגרם.

ניפוח context. אותו prompt ב-200K לעומת 800K context עולה 4 פעמים יותר. כל Read, Grep, Edit שולח מחדש את ה-context המלא. prompt מורכב אחד מפעיל 15+ קריאות API, כל אחת מוכפלת בגודל ה-context שלך.

הכל ידני. ניהול context, תזמון פקיעת cache, האצלת SubTask, ניקוי סשן. אף אחד לא יכול לעקוב אחרי כל זה בזמן שהוא מקודד בפועל.

Max Plan ($200/חודש)? כל האמור לעיל, בנוסף למגבלת קצב של 5 שעות שהורגת את הזרימה שלך ללא טיימר ולא ETA.

API לפי שימוש? כל האמור לעיל, אלא שאין תקרה. miss cache אחד = $9 כסף אמיתי. עשר פעמים בשבוע = $360/חודש על תאונות בלבד. יום שלישי גרוע עם context מנופח יכול לעלות יותר ממה שמנוי Max Plan משלם בחודש.

claude-code-token-saver מטפל בכל זה אוטומטית. מתקין פעם אחת. גמרנו.

🚀 התקנה

/plugin marketplace add ww-w-ai/marketplace
/plugin install claude-code-token-saver@ww-w-ai

עובד אוטומטית לאחר ההתקנה. ללא הגדרה. דורש Claude Code v2.1.71+.

למעקב חי:

/setup-statusline install

לגזירת 2,200 טוקנים נסתרים מהוראות git המובנות של CC (פרטים):

/setup-git-lite install

🛡️ תכונה 1: Token Guardian

מזהה פקיעת cache וחוסם אוטומטית שליחות חוזרות יקרות.

TTL ה-cache של prompt ב-Claude Code הוא שעה אחת. התרחק יותר משעה וה-cache יפוג. ההודעה הבאה שלך תשלח מחדש את כל ה-context במחיר מלא. ב-900K טוקנים, זה $9 בבת אחת.

Token Guardian עוקב מתי התקבלה התשובה האחרונה. אם עברו יותר מ-3,590 שניות (TTL פחות חיץ של 10 שניות), הוא חוסם את ה-prompt ומציג אזהרה.

🚨 Cache expired (68m 23s idle)

The prompt cache has expired. Continuing will resend the full context.
Cost may increase significantly.

👉 /context — Check current context usage before deciding
👉 /clear → /cc-continue — Reset, then restore previous context (recommended, cheapest)
👉 Re-send — Continue as-is (full re-cache cost incurred)

פשוט שלח מחדש את אותו prompt לאחר האזהרה -- הוא יעבור. האזהרה מופעלת פעם אחת בלבד לכל תקופת חוסר פעילות, אז היא אף פעם לא מטרידה. הודעות האזהרה מוצגות ב-23 שפות בהתאם ל-locale של מערכת ההפעלה שלך.

תוצאה: כל פקיעת cache שנלכדת = $9 חסכון. ב-catch אחד ביום, זה $270/חודש של בזבוז טהור שנמנע.

אם אתה משתמש ב-API לפי שימוש, זה פוגע יותר קשה. מנויי Max Plan מאבדים $9 בתוך חיץ של $200. אתה מאבד $9 כסף אמיתי — בשקט, שוב ושוב, בכל פעם שאתה מתרחק. Token Guardian לוכד את זה בכל פעם.

🧠 תכונה 2: ארכיטקטורת סשן חכמה

התקן אותו ודפוסי עבודה מותאמי עלויות נכנסים לפעולה אוטומטית.

רוב המשתמשים עושים הכל בסשן Main. קריאת קבצים, יצירת קוד, הרצת בדיקות. כל פלט מצטבר ב-context ונשלח מחדש עם כל הודעה. הסשן מתנפח. העלויות גדלות כמו כדור שלג.

Session Architect מזריק אוטומטית אסטרטגיית האצלה בתחילת הסשן.

	Main Session	SubTask
תפקיד	עיצוב, החלטות, סקירה	מימוש, יצירת קוד, ריבוי קבצים
שכבת cache	שעה אחת (ephemeral_1h)	5 דקות
עלות כתיבת cache	＄10/MTok	＄6.25/MTok
גודל context	~94K ממוצע	~33K ממוצע

ל-SubTasks יש 37.5% כתיבת cache זולה יותר מ-Main. ה-context גם הוא הרבה יותר קטן. האצלת עבודה כבדה ל-SubTasks מורידה עלויות באופן דרמטי.

תוצאה: Context נשאר מתחת ל-250K במקום לגדול ל-600K+. אותו פלט עבודה, מחצית עלות הטוקן. אוטומטי לגמרי.

🪶 Concise Mode

אותו תוכן. פחות ריפוד. פועל כברירת מחדל.

hook ה-SessionStart גם מזריק כלל סגנון תגובה שפועל בכל סשן וכל מודל — ללא דגלים, ללא הגדרה. שלושה דברים משתנים:

ללא מבוא — לא "תן לי לבדוק...", "עכשיו אני...", חזרה על שאלתך, או סיכום מה שה-diff כבר מראה
הפורמט הנכון לתוכן — נקודות לרשימות, פרוזה להיגיון (פשרות, סיבתיות, נימוקים). אף אחד לא נאכף
ביטוי הדוק יותר — אותה נקודה, פחות מילים. פרוזה ברורה יותר היא פרוזה קצרה יותר

גבול קשיח: לעולם לא לנטוש תוכן, לדלג על אימות, או לדחוס ניואנסים למשפט אחד. המהות נשארת מלאה; רק האריזה מצטמקת.

מתקין פעם אחת, חל בכל מקום.

🔄 תכונה 3: /cc-continue — שחזור Context

מחליף את /compact. אפס קריאות LLM. אפס עלות טוקן. אפס אובדן מידע.

/compact שולח את כל ה-context שלך (~1M טוקנים) ל-LLM כדי לדחוס אותו לסיכום של 3.3%. אם ה-cache פג, זה לבד מפעיל cache מחדש מלא. אובדן מידע הוא בלתי נמנע.

/cc-continue לוקח גישה שונה לחלוטין. הוא מעבד מראש את transcript הסשן הקודם וטוען אותו ישירות. אין קריאת LLM. אין עלות. השיחה המקורית משוחזרת כפי שהיא.

	/compact	/cc-continue
איך זה עובד	שולח context מלא ל-LLM לסיכום	מעבד transcript מראש, קורא ישירות
קריאות LLM	נדרש (בדרך כלל 100K+ טוקנים)	0
עלות טוקן	גבוהה	0
אובדן מידע	כן (סיכום 3.3%)	אין (מקור שמור)
מהירות עיבוד	עשרות שניות	< 1 שנייה (אפילו קבצי 60MB+)
כשה-cache פג	עלות cache מחדש מלאה נוספת	אין השפעה
שחזור ריבוי סשנים	לא אפשרי	נתמך

שימוש: /clear ואז /cc-continue. תראה רשימת סשנים קודמים. בחר אחד לשחזור. לשחזור מהיר: /cc-continue last.

תוצאה: חזור לעבודה קודמת ללא עלות. אין אובדן מידע. מעבד transcripts של 60MB+ תוך פחות משנייה.

🤝 בן הזוג שלו: `/cc-compact` — מסירת השכבה הנסתרת

/cc-continue משחזר את ה-transcript — מה שאתה ו-Claude אמרתם. אבל הידע השימושי ביותר בסשן עבודה חי לעיתים קרובות מחוץ לדיאלוג הזה: מה ש-sub-agent גילה (ה-transcript שלו הוא קובץ נפרד שהשחזור לעולם לא טוען), מספר מכריע בפלט של כלי (מספר בדיקות, benchmark), או לקח שנלמד מהתהליך ("לא הצלחתי לשחזר headless ← הבעיה הייתה ב-build, לא בקוד").

הרץ /cc-compact בסוף סשן והוא יזקק בדיוק את השכבה הנסתרת הזו למסמך מסירה, שנשמר ב-~/.claude/claude-code-token-saver-data/<project>/handoff.md. בסשן הבא, /cc-continue טוען אותו אוטומטית מעל ה-transcript המשוחזר — בלי הדבקה.

זרימת העבודה: סיים סשן עם `/cc-compact` ← התחל את הבא עם `/cc-continue`.

📊 תכונה 4: שורת סטטוס חיה

ניטור טוקן/עלות בזמן אמת. פחות מ-50ms overhead.

הרץ /setup-statusline install פעם אחת ושורת סטטוס קבועה תופיע בתחתית Claude Code.

פעולה רגילה — כל מדד במבט אחד, אפס החלפת context:

מגבלת קצב הושגה — 5H הופך לאדום ב-102%, ספירה לאחור מראה בדיוק מתי חוזרים, ופעולת /report-limit בהקשה אחת עולה אוטומטית:

מחוון	מה הוא מציג	🟢 רגיל	🟡 אזהרה	🔴 קריטי
RUN (delta)	עלות קריאת API האחרונה	< ＄0.30	>= ＄0.30	>= ＄1.00
RUN (cumulative)	עלות מצטברת עבור תיקייה זו	—	—	—
5H	שימוש בחלון 5 שעות + ספירה לאחור לאיפוס	< 70%	>= 70%	>= 90%
CTX	שימוש בחלון context	< 35%	>= 35%	>= 70%

כשמחוון כלשהו מגיע לרמת אזהרה או קריטי, רמז → /usage-view current מופיע אוטומטית.

להסרה: /setup-statusline uninstall (תצורה קודמת משוחזרת אוטומטית).

תוצאה: כל בעיית עלות גלויה בזמן אמת. פחות מ-50ms overhead — ללא עיכוב מורגש.

משתמש ב-API לפי שימוש? מחווני 5H ו-W נסתרים אוטומטית — אין לך חלונות מגבלת קצב. מה שנשאר הוא מה שחשוב: RUN (עלות בזמן אמת לתור) ו-CTX (גודל context). שתי הידיות שמשמשות לשליטה בחשבון שלך, גלויות תמיד.

📈 לוח שימוש (/usage-view)

סוף סוף עניין: "לאן הלך כל הכסף הזה?"

משתמשי Max Plan מגיעים למגבלת קצב ותוהים מדוע. משתמשי API פותחים את חשבונית Anthropic ותוהים איך. בכל מקרה, השאלה זהה: איזה סשן שרף הכי הרבה טוקנים? מתי העלויות קפצו? אילו דפוסים קיימים בשימוש שלך? עד כה — הכל בלתי נראה.

/usage-view מציג הכל. לוח HTML אינטראקטיבי נפתח בדפדפן שלך, ומאפשר לנתח דפוסי שימוש ולאתר את הגורם השורשי לעליות עלויות. אין תלויות חיצוניות. עובד עצמאית. ניתן לשיתוף כקובץ.

$4,196 ב-31 ימים. לאן הלך הכל? מבט אחד — עלות כוללת, פירוט טוקן לפי סוג, יחס יעילות cache, ומספר סשנים. תרשים הסופגנייה מראה מיד ש-65% מהוצאותיך הן cache reads (שזה נורמלי ובריא):

לפני ואחרי — נמדד, לא מנוחש. הסמן המקווקו הכתום "Plugin installed" מפצל את ציר הזמן של העלויות שלך לשניים. עמודות יומיות מוערמות לפי סוג טוקן (Input/Output/Cache Write/Cache Read) כדי שתראה בדיוק איזה רכיב השתנה לאחר ההתקנה. קו הממוצע מציג את המגמה:

מתי אתה שורף הכי הרבה? עלות לפי שעה בשעות היום ופירוט לפי ימי השבוע. החלף בין ממוצע ימים פעילים, ממוצע כל הימים, או מקסימום. אייקוני אש מסמנים את השעות היקרות ביותר שלך — דפוסים ברורים (ריצות לילה, עליות ברביעי) קופצות מיד:

האם אתה נעשה יעיל יותר? יחס Total/Output מודד כמה טוקנים נצרכים לכל טוקן פלט שנוצר. נמוך יותר עדיף. הסמן "Plugin installed" מאפשר השוואה לפני ואחרי. עליות = cache misses או הפעלות מחדש של סשן:

כל קריאת API, מוצגת לפי גודל context ועלות. זה התרשים שמבהיר את מבנה העלויות. כל נקודה היא קריאת API אחת. אדום = Opus, כחול = Sonnet, ירוק = Haiku. הקווים המקווקווים הם תמחור תיאורטי — אם הנקודות שלך נמצאות מעל הקו, אתה משלם יתר. עבור לתצוגת User Turn כדי לראות עלות לפי תור שיחה במקום לפי קריאת API. העבר את העכבר על כל נקודה כדי לראות את טקסט ה-prompt בפועל, ספירת טוקנים ופירוט עלות מלא (Input/Output/Cache Write/Cache Read):

כמה גדולים ה-contexts שלך? רוב הקריאות מתכנסות מתחת ל-250K. הזנב הארוך מעל 350K הוא המקום שבו העלויות מתפוצצות — תרשים זה מראה בדיוק כמה פעמים אתה באזור הסכנה:

לוח הקידוד שלך, מתומחר לפי שעה. מפת חום של חלון 5 שעות על פני 30 ימים. ירוק (<$15/ש), כתום ($15-30/ש), אדום ($30+/ש). אייקון הגולגולת (💀) מסמן חלונות שבהם הגעת למגבלת קצב. מחוון העלות בחלק העליון מסנן חלונות זולים כדי שיקרים יבלטו — גרור כדי למצוא את הימים הגרועים ביותר שלך מיד. החלף בין תצוגות חלון 5 שעות ובלוק שעה אחת:

לחץ על תא כלשהו כדי לנתח את הסשנים של אותו חלון. כל סשן בפרק הזמן הזה, עם עלות, מספר הודעות, פירוט טוקנים, וההודעות הראשונות/האחרונות בפועל מכל שיחה. הרחב "Top Token Conversations" כדי לראות אילו חילופים ספציפיים שרפו הכי הרבה — כל ערך מציג את טקסט ה-prompt, תגי התראת עלות, ורמזי אופטימיזציה:

ניתוח מבוסס AI (אופציונלי). כשאתה מריץ /usage-view ללא --no-ai, אנליסט AI קורא את כל נתוני הלוח שלך — עם הפניה לתמחור API מובנה — ומפיק דוח כתוב: גורמי עלות, חריגות, המלצות אופטימיזציה. מוצג בשפת מערכת ההפעלה שלך אוטומטית (23 שפות, כולל RTL; תרשימים/טבלאות נשארים תמיד LTR):

לאן הלך הכסף — הוצאה כוללת, גורמי עלות לפי סוג טוקן, מגמה שבועית, והשפעת התוסף נמדדת במספרים אמיתיים:

מתי ואיך אתה עובד — שעות שיא, ימים הכי עמוסים, התפלגות קריאות API, ודפוסי מגבלת קצב שחושפים הזדמנויות אופטימיזציה:

מה לעשות בנוגע לכך — המלצות קונקרטיות ומבוססות נתונים מותאמות לשימוש האמיתי שלך. החלפת מודל, ניהול context, אסטרטגיית סשן:

שתף אותו. כל הלוח הוא קובץ HTML עצמאי יחיד — כל הנתונים מוטמעים, אין צורך בשרת. שלח לצוות, למנהל, או לרואה החשבון שלך. אין תלויות חיצוניות. עובד לא מקוון. השתמש במצב private כדי להסיר את כל טקסט ה-prompt לפני השיתוף — שומר על ניתוח העלויות תוך הסרת תוכן השיחה.

/usage-view                  # כל הזמן, כל הפרויקטים
/usage-view current          # רק חלון 5 השעות הנוכחי
/usage-view last 7 days      # 7 הימים האחרונים
/usage-view locale ja        # יפנית
/usage-view --no-ai          # דלג על ניתוח AI (מהיר יותר)
/usage-view private          # הסר טקסט prompt (בטוח לשיתוף)

🔬 מחקר מגבלת קצב (/report-limit)

פרויקט מונע קהילה לפענוח נוסחת מגבלת הקצב.

Anthropic לא מפרסמת את הנוסחה המדויקת לחלון 5 השעות. בואו נפענח אותה ביחד.

כשאתה מגיע למגבלת קצב, הרץ /report-limit. נתוני השימוש הנוכחיים שלך מוגשים אוטומטית כ-GitHub Discussion. ככל שנאסוף יותר נתונים, כך הנוסחה תתבהר יותר.

✂️ תכונה 5: /setup-git-lite — קצץ את הוראות git המובנות של CC

קראנו את קוד המקור של Claude Code. מצאנו 2,200 טוקנים נסתרים שמוזרקים בכל סשן ואתה משלם עליהם בשקט.

הגילוי

ב-2026-04-12, issue ב-GitHub חשף שהגדרת includeGitInstructions המובנית של Claude Code שורפת טוקנים בשקט בכל סשן. שחזור עצמאי דרך gist זה (spilist) אישר את המספרים: +6,031 טוקנים בכתיבות cache לסשן לאחר כל git commit, +1,690 טוקנים בקריאות cache בכל קריאת API.

ניתוח קוד מקור CC — לאן הולכים הטוקנים

עקבנו אחרי הטוקנים לשני נקודות הזרקה עצמאיות בקוד המקור של Claude Code (v2.1.88):

1. snapshot gitStatus (~500 tok) — system prompt

context.ts:36-111 getGitStatus() אוסף branch + main branch + user.name + status מלא (עד 2000 תווים) + 5 commits אחרונים
מחובר ומצורף ל-system prompt דרך appendSystemContext (utils/api.ts:437)
כל commit חדש, כל קובץ שונה חדש, כל החלפת branch משנה את הטקסט → ביטול תקף cache prefix

2. הוראות workflow Commit/PR (~1,700 tok) — תיאור כלי Bash

tools/BashTool/prompt.ts:53 מצרף 60+ שורות של פרוטוקול בטיחות, נוהל commit שלב אחר שלב, דוגמאות HEREDOC, ותבניות יצירת PR לתיאור כלי ה-Bash
נשמר ב-cache יחד עם system prompt, אך נשלח כפרמטר tools[]

מדוע זה יקר

מבנה ה-cache (utils/api.ts:321 splitSysPromptPrefix) כולל שלושה נתיבים בהתאם לאם יש לך כלי MCP פעילים:

נתיב A (MCP פעיל — רוב המשתמשים): gitStatus יושב בתוך בלוק cacheScope: 'org'. כל שינוי → כל הבלוק מאוחסן מחדש ב-cache בתחילת הסשן הבא → 6K tok cache_create miss.
נתיב B (ללא MCP): gitStatus הולך לבלוק דינמי cacheScope: null, כלומר נשלח מחדש כ-input_tokens רענן בכל קריאת API — אין cache miss, אך גם אין חיסכון ב-cache.
נתיב C (ספק צד שלישי / בטא ניסיוניים מושבתים): זהה לנתיב A.

בסשנים אינטראקטיביים טיפוסיים, הוראות commit/PR (1.7K tok) מצטברות בכל קריאת API דרך cache_read. על פני סשן של 100 קריאות במחירי Opus 4.7, זה בערך $0.08 לסשן רק עבור הוראות שהאימון של Claude כבר מכסה את רובן.

איך claude-code-token-saver מטפל בזה

/setup-git-lite מכבה את הנתיב המקורי ומזריק תחליף מנוסח בקפידה של 280 טוקנים דרך hook של SessionStart. שמרנו בדיוק את הדברים שעוקפים את התנהגות ברירת המחדל של Claude (כללי בטיחות), והשלכנו את כל מה שClaude כבר יודע מהאימון (workflows שלב אחר שלב, תבניות PR, דפוסי שימוש ב-gh).

נשמר — 11 כללי עקיפה קריטיים (אלה שהופכים את העזרתיות המוגדרת כברירת מחדל של Claude לזהירות):

לעולם אל commit/push/amend/PR/tag/merge ללא בקשה מפורשת מהמשתמש
לעולם אל תדלג על hooks, force-push ל-main/master, הפעל פעולות הרסניות, שנה git config
לעולם אל תעשה commit לקבצים התואמים .env, credentials, *.pem, secret.*
הימנע מ-git add -A / git add .
HEREDOC להודעות commit מרובות שורות + trailer Co-Authored-By: Claude
לעולם אל תשתמש בדגלים אינטראקטיביים (-i), אין commits ריקים
אם hook pre-commit נכשל → צור commit חדש (לא --amend)

הושלך — workflow commit שלב אחר שלב (3 שלבים), workflow PR שלב אחר שלב (3 שלבים), תבנית כותרת/גוף PR, הפניות לפקודת gh, אזהרת דגל -uall, אזהרת --no-edit עם rebase, אילוץ NEVER use TodoWrite or Agent tools during commit. אלה הם פרטי workflow שClaude מרכיב נכון מהאימון לבד.

נוסף — שורת מצב git קומפקטית: branch + HEAD short-sha + subject + מצב נוכחי (עד 20 קבצים שונים, אחרת ספירה). אין רשימת commits אחרונים (Claude יכול להריץ git log לפי דרישה).

חיסכון צפוי (תמחור Opus 4.7, $25/MTok פלט, $5/MTok קלט, $0.50/MTok cache read)

פריט	מקורי	עם setup-git-lite	נחסך
טעינת system prompt (לסשן חדש)	~2,200 tok cache_create	~280 tok cache_create	~1,920 tok
קריאות חוזרות באותו סשן	~1,700 tok cache_read/קריאה	~280 tok cache_read/קריאה	~1,420 tok/קריאה
סשן של 100 קריאות (Opus 4.7)	—	—	~$0.11 נחסך
20 סשנים/יום × 22 ימי עבודה	—	—	~$48 נחסך/חודש

שימוש

/setup-git-lite status     # אבחון קריאה בלבד — מצב נוכחי + מה ישתנה
/setup-git-lite install    # השבת CC native + הפעל את ה-hook המינימלי שלנו
/setup-git-lite revert     # שחזר ברירת מחדל (אגרסיבי; ראה להלן)
/setup-git-lite dismiss-banner    # השתק את רמז ההמלצה המזדמן
/setup-git-lite undismiss-banner  # הפעל מחדש את הרמז
/setup-git-lite help       # שימוש מלא

סמנטיקת התקנה

install משנה שני מקומות לחוסן:

~/.claude/settings.json — מוסיף "includeGitInstructions": false
Shell profile (~/.zshrc, ~/.bashrc, וכו') — מצרף בלוק סמן שמייצא CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1

כל אחד מהם לבד מספיק כדי להשבית CC native; אנו מגדירים את שניהם כדי שעקיפה סביבתית לא תפעיל מחדש בטעות את ההתנהגות המקורית. שינוי ה-shell נכנס לתוקף רק ב-shells חדשים.

סמנטיקת revert — אגרסיבית

revert מסיר את כל exports CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS מה-shell profile שלך, כולל כל אלה שאולי הוספת ידנית לפני התקנת ה-skill הזה. זה מכוון — הרצת revert, אז אנו משחזרים את ברירת המחדל הנקייה. אנו תמיד יוצרים גיבוי עם חותמת זמן של ה-shell profile תחילה.

אם אתה צריך את משתנה הסביבה מסיבות לא קשורות, רשום אותו לפני הרצת revert והוסף אותו מחדש לאחר מכן.

לפני הסרת התקנה של claude-code-token-saver

הרץ /setup-git-lite revert תחילה, או שתישאר עם includeGitInstructions: false ב-settings.json שלך אך ללא hook חלופי (Claude לא מקבל הנחיות git בכלל). ל-Claude Code כיום אין hook מחזור חיים להסרת התקנת plugin, אז אנחנו לא יכולים להפוך את זה לאוטומטי.

פשרות

מה שאתה מאבד (ולמה זה בדרך כלל בסדר):

Claude לא מקבל עוד git status / git log -n 5 מחושב מראש בתחילת הסשן. אם תשאל "מה השתנה?" בסשן חדש, Claude יריץ את הפקודות הללו בעצמו (קריאת כלי נוספת אחת, ~300 tok).
Claude לא רואה עוד את נוהל ה-commit הקנוני של CC ב-3 שלבים. בבדיקות שלנו על פני מאות זרמי commit, ידע ברמת האימון מטפל במקרים הקריטיים (עיצוב HEREDOC, לא --amend, לא force-push) מכיוון שאנו שומרים אותם ככללים מפורשים.
תבנית גוף PR (## Summary + ## Test plan) אינה מוזרקת. אם אכפת לך מהפורמט הזה בדיוק, שים אותו ב-CLAUDE.md של הפרויקט שלך.

באנר המלצה

כשהוראות git המקוריות של CC עדיין פעילות במכונה שלך, claude-code-token-saver מציג רמז של פסקה אחת בתחילת הסשן ~20% מהזמן (בנוסף לפלט /usage-view ו-/report-limit). השתק לצמיתות עם /setup-git-lite dismiss-banner.

💡 איך Cache באמת עובד (ולמה רוב המשתמשים מבזבזים 40%+ עליו)

Claude Code שולח את כל היסטוריית השיחה למודל בכל קריאת API. "קריאת API" לא אומר "הודעה אחת שהקלדת." prompt בודד מפעיל קריאות כלי פנימיות — Grep, Read, Edit, Write — וכל אחת היא קריאת API נפרדת. prompt אחד יכול בקלות לגרום ל-10+ קריאות API.

Prompt cache מפחית עלות זו ב-90%. אבל ל-cache יש אורך חיים.

	Main Session	SubTask
Cache TTL	שעה אחת (ephemeral_1h)	5 דקות
כתיבת cache	＄10/MTok	＄6.25/MTok
קריאת cache	＄0.50/MTok	＄0.50/MTok
כשה-cache פג	Context מלא נשלח מחדש במחיר מלא	השפעה נמוכה (context קטן)

גם עם cache פעיל, עלויות מצטברות. הנה תרחיש קיצוני כדי להראות את ההבדל.

תרחיש: יום קידוד מלא (3 שעות בוקר → 2 שעות צהריים/ישיבה → 3 שעות אחה"צ)

תנאים: תמחור Opus 4, prompt אחד לדקה, ~5 קריאות API לprompt (~300 קריאות/שעה).

❌ ללא claude-code-token-saver

רוב העבודה מתרחשת בסשן Main. Context גדל מהר.

שלב	מצב	גודל Context	עלות
בוקר 3ש	קידוד (בעיקר ב-Main)	100K → 600K (ממוצע 350K)	900 קריאות × 350K × ＄0.50/M = ＄157.50
צהריים/ישיבה	משך 2 שעות	—	—
חזרה	Cache פג → שליחה מחדש מלאה	600K מחיר מלא	600K × ＄5/M + 600K × ＄10/M = ＄9
חזרה	/compact (סכם)	600K → נשלח ל-LLM	600K × ＄0.50/M + פלט סיכום = ~＄1.50
אחה"צ 3ש	קידוד ממשיך (context גדל מחדש)	100K → 600K (ממוצע 350K)	900 קריאות × 350K × ＄0.50/M = ＄157.50
	סך הכל		~＄326

ברמת שימוש זו, כנראה תגיע למגבלת קצב חלון 5 השעות. העלות גרועה, אבל הבעיה האמיתית היא שהעבודה שלך עוצרת לחלוטין. זה הרגע המדויק שבו Claude Code הולך לאפלה.

✅ עם claude-code-token-saver

עבודה כבדה מואצלת ל-SubTasks. Main מטפל רק בעיצוב/החלטות.

שלב	מצב	גודל Context	עלות
בוקר 3ש	קידוד (Main: עיצוב, SubTask: מימוש)	Main 100K → 300K (ממוצע 200K)	900 קריאות × 200K × ＄0.50/M = ＄90
צהריים/ישיבה	משך 2 שעות	—	—
חזרה	⚡ Token Guardian חוסם → /clear + /cc-continue	—	＄0 (אין קריאות LLM)
אחה"צ 3ש	קידוד ממשיך	Main 100K → 300K (ממוצע 200K)	900 קריאות × 200K × ＄0.50/M = ＄90
	סך הכל		~＄180

💰 תוצאה

＄326 → ＄180. ＄146 נחסכים ביום. הפחתת עלויות של 45%.

Max Plan: פחות טוקנים = לא מגיעים למגבלת קצב. העבודה שלך לא עוצרת. זה ההבדל האמיתי.

API לפי שימוש: ＄146/יום × 22 ימי עבודה = ＄3,200/חודש ישר מהחשבונית שלך. חודש כבד בלי התוסף הזה חוצה ＄7,000. איתו, מתחת ל-＄4,000. אותו פלט.

איפה claude-code-token-saver נכנס לפעולה

[Session Start]
    │
    ├─ Session Architect → מזריק אוטומטית דפוס האצלת SubTask
    │                       שומר context Main מתחת ל-250K
    │
[עובד]
    │
    ├─ Status Line → ניטור עלויות/context/מגבלת קצב בזמן אמת
    │                  התראה מיידית בכניסה לאזור אזהרה
    │
[חוסר פעילות 1+ שעה]
    │
    ├─ Token Guardian → מזהה פקיעת cache, חוסם לפני שליחה מחדש
    │
[הפעלה מחדש של סשן]
    │
    └─ /cc-continue → משחזר context קודם ללא עלות (אין קריאות LLM)

🔧 התקנת קוד מקור והתאמה אישית

git clone https://github.com/ww-w-ai/claude-code-token-saver.git
/plugin marketplace add /path/to/claude-code-token-saver
/plugin install claude-code-token-saver@ww-w-ai

claude-code-token-saver הוא קוד פתוח לחלוטין (Apache-2.0). JavaScript ו-Bash פשוטים — אין בינאריים מקומפלים, אין קריאות API חיצוניות, אין טלמטריה. כל שורה ניתנת לביקורת. כל טענה ב-README זה ממופה לקובץ ספציפי שאפשר לקרוא.

hooks/ — שנה סף פקיעת cache, התאם הודעות אזהרה, שנה כללי ארכיטקטורת סשן
scripts/ — לוגיקת ניתוח, בונה דוחות, עיצוב שורת סטטוס
skills/ — איך עובדים /cc-continue ו-/usage-view, תבניות prompt
locales/ — הוסף/ערוך תרגומים, הוסף שפות חדשות
skills/usage-view/ — שינויי עיצוב UI/UX של הלוח

הפוך אותו לשלך. עשה fork, נסה, ושלח PR אם מצאת משהו טוב יותר.

🌐 שפות נתמכות

23 שפות נתמכות. נבחרו על ידי הצלבת 20 המדינות המובילות לפי שימוש ב-Claude Code עם 20 השפות המובילות לפי מספר דוברים עולמי. שפת התצוגה מזוהה אוטומטית מה-locale של מערכת ההפעלה שלך. ניתן גם לציין ידנית: /usage-view locale ja


🇺🇸 English	🇰🇷 Korean	🇯🇵 Japanese	🇨🇳 Chinese
🇪🇸 Spanish	🇫🇷 French	🇩🇪 German	🇧🇷 Portuguese
🇮🇹 Italian	🇷🇺 Russian	🇸🇦 Arabic	🇮🇳 Hindi
🇧🇩 Bengali	🇮🇩 Indonesian	🇲🇾 Malay	🇹🇭 Thai
🇻🇳 Vietnamese	🇹🇷 Turkish	🇵🇱 Polish	🇳🇱 Dutch
🇮🇱 Hebrew	🇸🇪 Swedish	🇳🇴 Norwegian

התרגומים הנוכחיים נוצרו על ידי AI. תרומות של דוברי שפת אם מתקבלות בברכה — ערוך את קובץ ה-JSON לשפה שלך ב-locales/ ושלח PR.

⚖️ מה התוסף הזה עולה לך

התוסף מזריק context בתחילת הסשן. הנה בדיוק כמה:

הזרקה	מתי	טוקנים	מטרה
Session Architect	SessionStart (פעם אחת)	~1,100	אסטרטגיית האצלת SubTask + כללי concise mode
git context (אם git-lite מופעל)	SessionStart (פעם אחת)	~280	מחליף את הוראות ה-git המקוריות ~2,200 tok של CC
אזהרת פקיעת cache	בחוסר פעילות > 59 דקות (פעם אחת)	~200	חוסם שליחה מחדש יקרה, מציג אפשרויות שחזור
Status line	כל קריאת API	0	מעבד לשורת סטטוס טרמינל, לא ל-context שיחה

overhead נטו לסשן: ~1,400 טוקנים (חד פעמי, נשמר ב-cache לאחר הקריאה הראשונה).

במחירי Opus ($0.50/MTok cache read), זה $0.0007 לקריאת API — פחות מעשירית סנט. על פני סשן של 100 קריאות: $0.07.

אם git-lite מופעל, התוסף חוסך ~1,920 טוקנים לסשן (מחליף 2,200 ב-280). האפקט הנטו הוא שלילי — התוסף צורך פחות ממה שהוא מסיר.

למשתמשי API לפי שימוש: בהוצאה של $3,000/חודש, overhead התוסף הוא מתחת ל-$2/חודש. החיסכון מניעת פקיעת cache בלבד (שליחה חוזרת חסומה אחת של $9 בשבוע) משלמת שנה של overhead בתפיסה אחת.

💡 טיפים

הבן cache ותראה לאן הולך הכסף

1 prompt ≠ 1 קריאת API. בכל פעם שClaude קורא ל-Grep, Read, או Edit, כל ה-context נשלח מחדש. prompt בודד מפעיל בקלות 10+ קריאות API. כתוב prompts ברורים כדי להפחית קריאות כלי מיותרות ולהוריד עלויות.
טיימר ה-cache מאופס מקריאת API האחרונה, לא מ-prompt האחרון שלך. המשך לעבוד וה-cache לעולם לא יפוג. הסכנה היא ההתרחקות. Token Guardian חוסם אוטומטית פעם אחת, אז כשתחזור תוכל לבחור: אפס context או המשך כפי שהוא.
גודל context = מכפיל עלויות. אותה קריאת API ב-200K לעומת 800K עולה 4 פעמים יותר. כשה-[CTX] בשורת הסטטוס חוצה 35% (🟡), זה הסיגנל שלך להאציל יותר ל-SubTasks.

הרגלים שמורידים עלויות

שמור על CLAUDE.md קצר. הוא נטען ל-system prompt בכל קריאת API. כל שורה עולה כסף.
האצל עבודה כבדה ל-SubTasks. יצירת קוד, עריכת קבצים מרובים, הרצת בדיקות לא שייכות ל-Main. ל-SubTasks יש context קטן יותר ושכבת cache זולה יותר.
משך 1+ שעה? /clear → חזור → /cc-continue. Context משוחזר ב-$0.
[5H] מעל 70% (🟡)? האט. עבור למשימות סקירה קלות או הגדל האצלת SubTask כדי להפחית את מספר קריאות ה-API של Main.
השתמש ב-/btw לשאלות צדדיות. זה לא נכנס להיסטוריית השיחה, אז ה-context שלך נשאר קצר.

API לפי שימוש: ההרגלים שהכי חשובים

כל האמור לעיל חל, בנוסף לעדיפויות הספציפיות ל-API:

עקוב אחרי [CTX] כמו מד מהירות. אף מגבלת קצב לא תעצור אותך — אבל context ב-500K+ אומר שכל קריאת API עולה 2-3 פעמים יותר ממה שצריך. /clear → /cc-continue הוא בחינם ומאפס את מכפיל העלויות שלך לקו הבסיס.
הרץ /usage-view מדי שבוע. למשתמשי Max Plan יש רגע "אוי" טבעי כשהם מגיעים למגבלת קצב. לך אין — עלויות עולות בשקט. הלוח הוא מערכת האזהרה המוקדמת שלך.
קבע תקציב יומי נפשי. ללא תקרה, ימים של $200 קורים מבלי לשים לב. מחוון ה-RUN של שורת הסטטוס הופך עלות לפי תור לגלויה. אם תור בודד חוצה $1 (🔴), ה-context שלך גדול מדי.

📚 תיעוד

מדריך Prompt Cache — מדוע רוב העלות שלך היא cache, איך caching עובד אצל ספקים (Anthropic, OpenAI, Gemini), ואיך לנהל אותו (한국어 · 日本語 · 中文 · Español · Français · Deutsch · +16 languages)
ניתוח עלויות Opus 4.7 לעומת 4.6 — השוואת עלויות זה לצד זה על פני 8,563 קריאות API
ניתוח עלויות Opus 4.7 לעומת 4.6 (한국어)

רישיון

Apache-2.0

Uh oh!

FilesExpand file tree

README.he.md

Latest commit

History