usage-cli 0.34.15__tar.gz → 0.34.17__tar.gz

{usage_cli-0.34.15/usage_cli.egg-info → usage_cli-0.34.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.15
+Version: 0.34.17
 Summary: usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）
 License-Expression: AGPL-3.0-only
 Requires-Python: >=3.13
@@ -123,7 +123,7 @@ Once set up, the bottom of the Claude Code window will show a status line like t
 | **Token Saver** | Asks Claude Code and Codex for shorter, plainer replies while keeping code and error messages byte-exact. In an A/B test on real sessions, late replies stayed **~40% shorter** instead of drifting 84% longer. | Off · no extra model calls |
 | **Side pane** | Quotas, other conversations, and background jobs next to your work. [See the side pane](#claude-code-side-pane). | Off · no extra model calls |
 | **Beginner Mode** | Explains up to three technical terms from each answer in one plain line, then brings them back for review. | Off · a little Claude quota |
-| **Quota-Aware Mode** | When a quota runs low, Claude tells you before a big task that would use it, and lets you do a smaller part or wait for the reset. | Off · no extra model calls |
+| **Quota-Aware Mode** | When a quota runs low, Claude tells you before a big task that would use it, and lets you do a smaller part or wait for the reset. Claude also gets a short quota overview at the start of each conversation. | Off · no extra model calls |
 | **Auto-start 5-hour session** | Right after a 5-hour quota resets, sends each tool one tiny message so the next window starts counting right away. | Off · negligible quota |
 | **Token-waste health check** | A daily scan of your logs for repeated file reads and noisy output. Say "show me" and the AI walks you through fixes. | Comes with Progress Concierge · no extra model calls |
 
@@ -146,7 +146,7 @@ Once set up, the bottom of the Claude Code window will show a status line like t
 - **Linux:** CI verifies `usage setup` on Ubuntu.
 - **Progress Concierge:** When you `/resume` a conversation that sat long enough for its cache to expire, it warns how many tokens the next message will re-send and suggests `/compact` first.
 - **Beginner Mode (macOS and Windows):** Terms appear above the prompt in your UI language. Press 9 to mark them understood; skipped terms come back after 1, 3, then 7 days. Understood terms return as a one-question multiple-choice quiz 7, 21, then 60 days later, at most one a day, and a wrong answer puts the term back in the hints. `/terms` opens your term history. Picking terms asks Claude Haiku through your Claude Code, and pauses while your 5-hour quota is at 90% or more.
-- **Quota-Aware Mode (macOS and Windows):** Claude Code gets one line with what is left and when it resets when a 5-hour quota passes 80%, 90%, or 95%, or a weekly quota passes 95%. It covers Claude Code, Codex, Antigravity, and Muse, says each level once per conversation, and treats each quota and model group separately, so a used-up one only matters for work that runs on it.
+- **Quota-Aware Mode (macOS and Windows):** Claude Code gets one line with what is left and when it resets when a 5-hour quota passes 80%, 90%, or 95%, or a weekly quota passes 95%. It covers Claude Code, Codex, Antigravity, and Muse, says each level once per conversation, tells Claude once when a quota it warned about resets, and treats each quota and model group separately, so a used-up one only matters for work that runs on it. Official Claude Code / Claude API or Codex API incidents and recovery also notify Claude, once per status change in each conversation. Claude also gets a short quota overview at the start of each conversation. After `/login` changes accounts, Claude hears once that earlier Claude Code quota notices no longer apply.
 - **Auto-start 5-hour session:** Claude gets Haiku, Antigravity gets Gemini 3.8 Flash Low, and Codex gets its cheapest model. The quota used is negligible. The Claude and Codex pings skip your own hooks and stay out of `claude --resume` and `codex resume`.
 - **Panel:** It stays put when another app takes focus; a second click on the menu bar icon, or Escape, closes it. Card order is shared across every theme with quota cards (all except World Cup 2026) and survives restarts.
 - **HTML reports:** A "What you worked on" section lists the names Claude Code gave your recent conversations, and masking covers those titles too.

{usage_cli-0.34.15 → usage_cli-0.34.17}/README.md

@@ -101,7 +101,7 @@ Once set up, the bottom of the Claude Code window will show a status line like t
 | **Token Saver** | Asks Claude Code and Codex for shorter, plainer replies while keeping code and error messages byte-exact. In an A/B test on real sessions, late replies stayed **~40% shorter** instead of drifting 84% longer. | Off · no extra model calls |
 | **Side pane** | Quotas, other conversations, and background jobs next to your work. [See the side pane](#claude-code-side-pane). | Off · no extra model calls |
 | **Beginner Mode** | Explains up to three technical terms from each answer in one plain line, then brings them back for review. | Off · a little Claude quota |
-| **Quota-Aware Mode** | When a quota runs low, Claude tells you before a big task that would use it, and lets you do a smaller part or wait for the reset. | Off · no extra model calls |
+| **Quota-Aware Mode** | When a quota runs low, Claude tells you before a big task that would use it, and lets you do a smaller part or wait for the reset. Claude also gets a short quota overview at the start of each conversation. | Off · no extra model calls |
 | **Auto-start 5-hour session** | Right after a 5-hour quota resets, sends each tool one tiny message so the next window starts counting right away. | Off · negligible quota |
 | **Token-waste health check** | A daily scan of your logs for repeated file reads and noisy output. Say "show me" and the AI walks you through fixes. | Comes with Progress Concierge · no extra model calls |
 
@@ -124,7 +124,7 @@ Once set up, the bottom of the Claude Code window will show a status line like t
 - **Linux:** CI verifies `usage setup` on Ubuntu.
 - **Progress Concierge:** When you `/resume` a conversation that sat long enough for its cache to expire, it warns how many tokens the next message will re-send and suggests `/compact` first.
 - **Beginner Mode (macOS and Windows):** Terms appear above the prompt in your UI language. Press 9 to mark them understood; skipped terms come back after 1, 3, then 7 days. Understood terms return as a one-question multiple-choice quiz 7, 21, then 60 days later, at most one a day, and a wrong answer puts the term back in the hints. `/terms` opens your term history. Picking terms asks Claude Haiku through your Claude Code, and pauses while your 5-hour quota is at 90% or more.
-- **Quota-Aware Mode (macOS and Windows):** Claude Code gets one line with what is left and when it resets when a 5-hour quota passes 80%, 90%, or 95%, or a weekly quota passes 95%. It covers Claude Code, Codex, Antigravity, and Muse, says each level once per conversation, and treats each quota and model group separately, so a used-up one only matters for work that runs on it.
+- **Quota-Aware Mode (macOS and Windows):** Claude Code gets one line with what is left and when it resets when a 5-hour quota passes 80%, 90%, or 95%, or a weekly quota passes 95%. It covers Claude Code, Codex, Antigravity, and Muse, says each level once per conversation, tells Claude once when a quota it warned about resets, and treats each quota and model group separately, so a used-up one only matters for work that runs on it. Official Claude Code / Claude API or Codex API incidents and recovery also notify Claude, once per status change in each conversation. Claude also gets a short quota overview at the start of each conversation. After `/login` changes accounts, Claude hears once that earlier Claude Code quota notices no longer apply.
 - **Auto-start 5-hour session:** Claude gets Haiku, Antigravity gets Gemini 3.8 Flash Low, and Codex gets its cheapest model. The quota used is negligible. The Claude and Codex pings skip your own hooks and stay out of `claude --resume` and `codex resume`.
 - **Panel:** It stays put when another app takes focus; a second click on the menu bar icon, or Escape, closes it. Card order is shared across every theme with quota cards (all except World Cup 2026) and survives restarts.
 - **HTML reports:** A "What you worked on" section lists the names Claude Code gave your recent conversations, and masking covers those titles too.

{usage_cli-0.34.15 → usage_cli-0.34.17}/analyzer/reporter.py

@@ -45,7 +45,7 @@ _YEAR_WEEKS = 53
 YEAR_CACHE_PATH = Path(os.path.expanduser("~/.usage/year_cache.json"))
 YEAR_LEDGER_PATH = YEAR_CACHE_PATH.with_name("year_ledger.json")
 YEAR_CACHE_TTL_SECONDS = 6 * 3600
-_YEAR_CACHE_SCHEMA = 7
+_YEAR_CACHE_SCHEMA = 8
 _YEAR_LEDGER_SCHEMA = 1
 _year_ledger_lock = threading.RLock()
 _YEAR_LEDGER_TRIM_BUFFER_DAYS = 60

{usage_cli-0.34.15 → usage_cli-0.34.17}/i18n.json

@@ -338,8 +338,8 @@
     "project_butler_tooltip": "開新對話時，自動把上次的進度交給 AI，不用再重講一次。",
     "terse_mode_menu": "省 token 模式",
     "terse_mode_tooltip": "開新對話時，自動要求 Claude 回覆更簡短、更白話，以節省輸出 token（有裝 Codex 的話也會一起套用）；但程式碼、指令、路徑與錯誤訊息不會被縮減。之後你送的每則訊息也會輕聲提醒 Claude 維持精簡。",
-    "terse_reminder_instruction": "[精簡模式仍生效：這則回覆保持精簡、用白話；程式碼、指令、路徑、錯誤訊息照舊一字不改；安全警示與不可逆操作確認仍要講完整；使用者明確要求詳細解說時，以使用者當下的要求為準。]",
-    "terse_mode_instruction": "（這個對話已開啟「精簡模式」：請在這次對話第一則回覆的最前面提一下這件事——如果你同時收到其他要打招呼的指示（例如進度交接），就把「精簡模式已開啟」自然併入那句招呼裡就好，不要另外多開一句；如果沒有其他招呼可以搭，就自己說一行「🐾 已開啟精簡模式，回覆會盡量簡短，繼續吧！」。整個對話都適用。去掉虛詞贅字、客套語、重複鋪陳與不必要的過渡句；用詞挑簡短的（例如「修」不要「針對這個問題實作解決方案」）。精簡是預算，白話是風格：短不等於難懂。挑最口語的說法，能用日常字就不要用術語（例如「先存檔」不要「先持久化」）。非用不可的技術詞，第一次出現時在後面補十個字以內的白話解釋，之後直接用。工具或子代理的輸出不要原文轉貼：先讀懂再用白話重寫成結論，只有程式碼、指令、路徑、錯誤訊息照原文保留。不要比喻。名詞化還原成動詞：進行修改→改、做出決定→決定。刪只預告不給資訊的句子：接下來我要說明、值得注意的是、在深入之前。每句先已知後新知。一句只講一件事，一句盡量在三十字內。用主動句：寫「程式送出金鑰」，不寫「金鑰被程式送出」。同一個東西從頭到尾用同一個詞，叫過「hook」就別再換成「鉤子」。收尾就三件事：做了什麼、成功沒、下一步做什麼。不用裝飾性表格；除了開頭那句招呼，內文不放表情符號。不要複述工具名稱或呼叫過程，但開工具前用一句話說明要做什麼是可以的。不要自創縮寫（例如「設定」別縮成「設」、「函式」別縮成「函」）——這類縮寫斷詞長度跟完整詞一樣，省不到字數，反而讓讀者要多想一下，直接用完整詞更省事也更清楚。程式碼、指令、檔案路徑、錯誤訊息一個字都不能省略或改寫。遇到安全警示、不可逆操作的確認、或多步驟中省略連接詞會有誤讀風險的情況，這幾種要先恢復完整、講清楚，講完再切回精簡語氣。如果使用者明確要求詳細解說、逐步教學，或情境需要完整推理，仍以使用者當下的要求為準，不要因為這個模式而省略關鍵資訊。）",
+    "terse_reminder_instruction": "[精簡模式仍生效：這則回覆保持精簡、用白話、讀一遍就懂；程式碼、指令、路徑、錯誤訊息照舊一字不改；安全警示與不可逆操作確認仍要講完整；使用者明確要求詳細解說時，以使用者當下的要求為準。]",
+    "terse_mode_instruction": "（這個對話已開啟「精簡模式」：請在這次對話第一則回覆的最前面提一下這件事——如果你同時收到其他要打招呼的指示（例如進度交接），就把「精簡模式已開啟」自然併入那句招呼裡就好，不要另外多開一句；如果沒有其他招呼可以搭，就自己說一行「🐾 已開啟精簡模式，回覆會盡量簡短，繼續吧！」。整個對話都適用。去掉贅字（其實、基本上、真的）、客套語、重複鋪陳與不必要的過渡句；用詞挑簡短的（例如「修」不要「針對這個問題實作解決方案」）。精簡是預算，白話是風格：短不等於難懂。省字的底線是讀一遍就懂、不必回頭重讀；AI 味常常是省字省過頭造成的。讓讀者猜得到下一個詞：詞語照常見的搭配用；別讓東西做只有人會做的事，寫「快取存的是舊資料」，不寫「快取在說謊」；不用賦能、抓手、落地、閉環這類行話；不寫「這不是 X，而是 Y」的翻轉句，除非真的在糾正誤會。別讓讀者一次記太多：主詞和動詞擺近，名詞前面的長修飾語拆到下一句；名詞別疊成一串，寫「改快取過期後的處理方式」，不寫「快取失效處理機制調整」；「因為、所以、但是、如果」這類交代關係的詞，別為了省字拿掉。挑最口語的說法，能用日常字就不要用術語（例如「先存檔」不要「先持久化」）。非用不可的技術詞，第一次出現時在後面補十個字以內的白話解釋，之後直接用。工具或子代理的輸出不要原文轉貼：先讀懂再用白話重寫成結論，只有程式碼、指令、路徑、錯誤訊息照原文保留。不要比喻。名詞化還原成動詞：進行修改→改、做出決定→決定。刪只預告不給資訊的句子：接下來我要說明、值得注意的是、在深入之前。每句先已知後新知。一句只講一件事，一句盡量在三十字內。用主動句：寫「程式送出金鑰」，不寫「金鑰被程式送出」。同一個東西從頭到尾用同一個詞，叫過「hook」就別再換成「鉤子」。收尾就三件事：做了什麼、成功沒、下一步做什麼。不用裝飾性表格；除了開頭那句招呼，內文不放表情符號。不要複述工具名稱或呼叫過程，但開工具前用一句話說明要做什麼是可以的。不要自創縮寫（例如「設定」別縮成「設」、「函式」別縮成「函」）——這類縮寫斷詞長度跟完整詞一樣，省不到字數，反而讓讀者要多想一下，直接用完整詞更省事也更清楚。程式碼、指令、檔案路徑、錯誤訊息一個字都不能省略或改寫。遇到安全警示、不可逆操作的確認、或多步驟中省略連接詞會有誤讀風險的情況，這幾種要先恢復完整、講清楚，講完再切回精簡語氣。如果使用者明確要求詳細解說、逐步教學，或情境需要完整推理，仍以使用者當下的要求為準，不要因為這個模式而省略關鍵資訊。）",
     "terse_mode_enabled_msg": "已開啟。以後開新的 Claude Code 對話都會自動要求回覆更精簡、更白話（有裝 Codex 的話也會一起套用）；程式碼、指令、路徑和錯誤訊息不會被縮減。下次開新對話即生效。",
     "terse_mode_disabled_msg": "已關閉。開新對話時不再自動要求精簡回覆。",
     "resume_enabled_restart": "已開啟。以後開新的 Claude Code 對話，會自動記得這個專案上次做到哪——畫面上不會有提示（這是正常的），但 Claude 已經知道。下次開新對話即生效。",
@@ -556,7 +556,7 @@
     "claude_beginner_disabled_msg": "已關閉新手模式。重開 Claude Code 後生效。",
     "claude_beginner_action_failed": "無法切換新手模式",
     "quota_aware_menu": "額度感知模式",
-    "quota_aware_tooltip": "額度快用完時，Claude 開大任務前會先告訴你剩多少、幾點重置，讓你選先做小的還是等重置。",
+    "quota_aware_tooltip": "額度快用完時，Claude 開大任務前會先告訴你剩多少、幾點重置，讓你選先做小的還是等重置。Claude Code 或 Codex 官方服務出狀況時，也會告訴 Claude。每個對話開始時，也會給 Claude 一份各家額度的簡短總覽。",
     "quota_aware_enabled_msg": "已開啟額度感知模式。請重啟 Claude Code 套用。",
     "quota_aware_disabled_msg": "已關閉額度感知模式。請重啟 Claude Code 套用。",
     "quota_aware_action_failed": "無法切換額度感知模式。",
@@ -918,8 +918,8 @@
     "project_butler_tooltip": "When you open a new session, automatically hand your last progress to the AI — no need to re-explain.",
     "terse_mode_menu": "Token Saver",
     "terse_mode_tooltip": "When you open a new session, automatically ask Claude to reply more briefly and in plainer language to save output tokens (applies to Codex too, if it's installed); code, commands, paths, and error messages stay untouched. A light reminder is also injected after each message you send to keep replies terse.",
-    "terse_reminder_instruction": "[Terse mode is still on: keep this reply brief and plain-spoken; code, commands, paths, and error messages stay byte-exact; security warnings and irreversible-action confirmations must still be written out in full; if the user explicitly asks for a detailed walkthrough, follow that instead.]",
-    "terse_mode_instruction": "(Terse mode is on for this entire conversation. Mention this at the very start of your first reply — if you're already leading with another greeting (e.g. a resume handoff), fold \"terse mode is on\" into that same line instead of adding a separate one; if there's no other greeting to fold into, say your own line: \"🐾 Terse mode is on — keeping replies short, let's go!\" Drop filler (just/really/basically/actually) and pleasantries (sure/certainly/happy to). Prefer short synonyms (big, not extensive; fix, not \"implement a solution for\"). Terse is the budget; plain is the style — short must never mean cryptic. Pick the everyday word over the jargon one (\"save it first\", not \"persist it first\"). When a technical term is unavoidable, gloss it once on first use in eight words or fewer, then just use it. Never paste a tool's or subagent's output verbatim: read it, then rewrite it as a plain-language conclusion — only code, commands, paths, and error messages stay verbatim. No analogies. Zombie nouns to verbs: \"make a decision\" to \"decide\". Cut metadiscourse: \"Let me explain\", \"It's worth noting\", \"Before diving in\". Given info first in a sentence, new info last. One idea per sentence; keep sentences under about 20 words. Use active voice: \"the program sends the key\", not \"the key is sent\". One word for one thing: once you call it \"hook\", don't switch to \"callback\". Close with what you did, whether it worked, and what to do next. No decorative tables, and no emoji in the body beyond the opening greeting. Don't recite tool names or narrate calls — but one line of intent before running a tool is fine. Never invent abbreviations (cfg/impl/req/res) — the tokenizer splits them the same as the full word, so nothing is saved and the reader still has to decode it; use the full word instead. Code, commands, file paths, and error messages must stay byte-exact, never trimmed or rewritten. Drop terseness for security warnings, irreversible-action confirmations, and multi-step instructions where a fragment or dropped conjunction risks being misread — write those out in full, then resume terse mode after. If the user explicitly asks for a detailed walkthrough, step-by-step teaching, or the situation needs full reasoning, follow that instead — don't drop essential information just to stay terse.)",
+    "terse_reminder_instruction": "[Terse mode is still on: keep this reply brief, plain-spoken, and clear on a first read; code, commands, paths, and error messages stay byte-exact; security warnings and irreversible-action confirmations must still be written out in full; if the user explicitly asks for a detailed walkthrough, follow that instead.]",
+    "terse_mode_instruction": "(Terse mode is on for this entire conversation. Mention this at the very start of your first reply — if you're already leading with another greeting (e.g. a resume handoff), fold \"terse mode is on\" into that same line instead of adding a separate one; if there's no other greeting to fold into, say your own line: \"🐾 Terse mode is on — keeping replies short, let's go!\" Drop filler (just/really/basically/actually) and pleasantries (sure/certainly/happy to). Prefer short synonyms (big, not extensive; fix, not \"implement a solution for\"). Terse is the budget; plain is the style — short must never mean cryptic. The floor for cutting: the reader gets it in one pass, without rereading. Much AI-sounding prose comes from cutting below that floor. Keep the next word predictable: use common word pairings; don't give things human actions (\"the cache holds stale data\", not \"the cache is lying\"); don't turn nouns into verbs (\"show the error\", not \"surface the error\"); no buzzwords like leverage or empower; skip the \"it's not X, it's Y\" reversal unless you're correcting a real misunderstanding. Don't make the reader hold too much in mind: keep the verb close to its subject and move long modifiers to the next sentence; unstack noun piles (\"fix how the cache handles expiry\", not \"fix the cache expiry handling logic\"); keep small words that mark structure, like \"that\" (\"she knew that the answer was wrong\") and because/so/but/if. Pick the everyday word over the jargon one (\"save it first\", not \"persist it first\"). When a technical term is unavoidable, gloss it once on first use in eight words or fewer, then just use it. Never paste a tool's or subagent's output verbatim: read it, then rewrite it as a plain-language conclusion — only code, commands, paths, and error messages stay verbatim. No analogies. Zombie nouns to verbs: \"make a decision\" to \"decide\". Cut metadiscourse: \"Let me explain\", \"It's worth noting\", \"Before diving in\". Given info first in a sentence, new info last. One idea per sentence; keep sentences under about 20 words. Use active voice: \"the program sends the key\", not \"the key is sent\". One word for one thing: once you call it \"hook\", don't switch to \"callback\". Close with what you did, whether it worked, and what to do next. No decorative tables, and no emoji in the body beyond the opening greeting. Don't recite tool names or narrate calls — but one line of intent before running a tool is fine. Never invent abbreviations (cfg/impl/req/res) — the tokenizer splits them the same as the full word, so nothing is saved and the reader still has to decode it; use the full word instead. Code, commands, file paths, and error messages must stay byte-exact, never trimmed or rewritten. Drop terseness for security warnings, irreversible-action confirmations, and multi-step instructions where a fragment or dropped conjunction risks being misread — write those out in full, then resume terse mode after. If the user explicitly asks for a detailed walkthrough, step-by-step teaching, or the situation needs full reasoning, follow that instead — don't drop essential information just to stay terse.)",
     "terse_mode_enabled_msg": "Enabled. New Claude Code sessions will automatically ask for terser, plainer replies (Codex too, if it's installed), while code, commands, paths, and error messages stay untouched. Takes effect the next time you start a session.",
     "terse_mode_disabled_msg": "Disabled. New sessions will no longer auto-request terse replies.",
     "resume_enabled_restart": "Enabled. New Claude Code sessions will automatically know where you left off in this project — you won't see a prompt (that's expected), but Claude will. Takes effect the next time you start a session.",
@@ -1136,7 +1136,7 @@
     "claude_beginner_disabled_msg": "Beginner Mode disabled. Restart Claude Code to apply.",
     "claude_beginner_action_failed": "Could not change Beginner Mode",
     "quota_aware_menu": "Quota-Aware Mode",
-    "quota_aware_tooltip": "When quota is running low, Claude tells you how much remains and when it resets before starting a large task, so you can choose a smaller part now or wait for the reset.",
+    "quota_aware_tooltip": "When quota is running low, Claude tells you how much remains and when it resets before starting a large task, so you can choose a smaller part now or wait for the reset. Claude is also notified of official Claude Code or Codex service incidents. Claude also gets a short quota overview at the start of each conversation.",
     "quota_aware_enabled_msg": "Quota-Aware Mode enabled. Restart Claude Code to apply.",
     "quota_aware_disabled_msg": "Quota-Aware Mode disabled. Restart Claude Code to apply.",
     "quota_aware_action_failed": "Could not change Quota-Aware Mode.",
@@ -1498,8 +1498,8 @@
     "project_butler_tooltip": "开新对话时，自动把上次的进度交给 AI，不用再重讲一次。",
     "terse_mode_menu": "省 token 模式",
     "terse_mode_tooltip": "开新对话时，自动要求 Claude 回复更简短、更白话，以节省输出 token（装了 Codex 的话也会一起套用）；但代码、指令、路径和错误信息不会被缩减。之后你发的每则消息也会轻声提醒 Claude 保持精简。",
-    "terse_reminder_instruction": "[精简模式仍生效：这则回复保持精简、用白话；代码、指令、路径、错误信息照旧一字不改；安全警示与不可逆操作确认仍要讲完整；用户明确要求详细讲解时，以用户当下的要求为准。]",
-    "terse_mode_instruction": "（这个对话已开启「精简模式」：请在这次对话第一则回复的最前面提一下这件事——如果你同时收到其他要打招呼的指示（例如进度交接），就把「精简模式已开启」自然并入那句招呼里就好，不要另外多开一句；如果没有其他招呼可以搭，就自己说一行「🐾 已开启精简模式，回复会尽量简短，继续吧！」。整个对话都适用。去掉虚词赘字、客套语、重复铺陈和不必要的过渡句；用词挑简短的（例如「修」不要「针对这个问题实现解决方案」）。精简是预算，白话是风格：短不等于难懂。挑最口语的说法，能用日常字就不要用术语（例如「先保存」不要「先持久化」）。非用不可的技术词，第一次出现时在后面补十个字以内的白话解释，之后直接用。工具或子代理的输出不要原文转贴：先读懂再用白话重写成结论，只有代码、指令、路径、错误信息照原文保留。不要比喻。名词化还原成动词：进行修改→改、做出决定→决定。删只预告不给信息的句子：接下来我要说明、值得注意的是、在深入之前。每句先已知后新知。一句只讲一件事，一句尽量在三十字内。用主动句：写「程序发送密钥」，不写「密钥被程序发送」。同一个东西从头到尾用同一个词，叫过「hook」就别再换成「钩子」。收尾就三件事：做了什么、成功没、下一步做什么。不用装饰性表格；除了开头那句招呼，正文不放表情符号。不要复述工具名称或调用过程，但开工具前用一句话说明要做什么是可以的。不要自创缩写（例如「配置」别缩成「配」、「函数」别缩成「函」）——这类缩写分词长度跟完整词一样，省不到字数，反而让读者要多想一下，直接用完整词更省事也更清楚。代码、指令、文件路径、错误信息一个字都不能省略或改写。遇到安全警示、不可逆操作的确认、或多步骤中省略连接词会有误读风险的情况，这几种要先恢复完整、讲清楚，讲完再切回精简语气。如果用户明确要求详细讲解、逐步教学，或情境需要完整推理，仍以用户当下的要求为准，不要因为这个模式而省略关键信息。）",
+    "terse_reminder_instruction": "[精简模式仍生效：这则回复保持精简、用白话、读一遍就懂；代码、指令、路径、错误信息照旧一字不改；安全警示与不可逆操作确认仍要讲完整；用户明确要求详细讲解时，以用户当下的要求为准。]",
+    "terse_mode_instruction": "（这个对话已开启「精简模式」：请在这次对话第一则回复的最前面提一下这件事——如果你同时收到其他要打招呼的指示（例如进度交接），就把「精简模式已开启」自然并入那句招呼里就好，不要另外多开一句；如果没有其他招呼可以搭，就自己说一行「🐾 已开启精简模式，回复会尽量简短，继续吧！」。整个对话都适用。去掉赘字（其实、基本上、真的）、客套语、重复铺陈和不必要的过渡句；用词挑简短的（例如「修」不要「针对这个问题实现解决方案」）。精简是预算，白话是风格：短不等于难懂。省字的底线是读一遍就懂、不用回头重读；AI 味常常是省字省过头造成的。让读者猜得到下一个词：词语按常见的搭配用；别让东西做只有人会做的事，写「缓存存的是旧数据」，不写「缓存在撒谎」；不用赋能、抓手、落地、闭环这类黑话；不写「这不是 X，而是 Y」的反转句，除非真的在纠正误会。别让读者一次记太多：主语和动词放近，名词前面的长修饰语拆到下一句；名词别叠成一串，写「改缓存过期后的处理方式」，不写「缓存失效处理机制调整」；「因为、所以、但是、如果」这类交代关系的词，别为了省字删掉。挑最口语的说法，能用日常字就不要用术语（例如「先保存」不要「先持久化」）。非用不可的技术词，第一次出现时在后面补十个字以内的白话解释，之后直接用。工具或子代理的输出不要原文转贴：先读懂再用白话重写成结论，只有代码、指令、路径、错误信息照原文保留。不要比喻。名词化还原成动词：进行修改→改、做出决定→决定。删只预告不给信息的句子：接下来我要说明、值得注意的是、在深入之前。每句先已知后新知。一句只讲一件事，一句尽量在三十字内。用主动句：写「程序发送密钥」，不写「密钥被程序发送」。同一个东西从头到尾用同一个词，叫过「hook」就别再换成「钩子」。收尾就三件事：做了什么、成功没、下一步做什么。不用装饰性表格；除了开头那句招呼，正文不放表情符号。不要复述工具名称或调用过程，但开工具前用一句话说明要做什么是可以的。不要自创缩写（例如「配置」别缩成「配」、「函数」别缩成「函」）——这类缩写分词长度跟完整词一样，省不到字数，反而让读者要多想一下，直接用完整词更省事也更清楚。代码、指令、文件路径、错误信息一个字都不能省略或改写。遇到安全警示、不可逆操作的确认、或多步骤中省略连接词会有误读风险的情况，这几种要先恢复完整、讲清楚，讲完再切回精简语气。如果用户明确要求详细讲解、逐步教学，或情境需要完整推理，仍以用户当下的要求为准，不要因为这个模式而省略关键信息。）",
     "terse_mode_enabled_msg": "已开启。以后开新的 Claude Code 对话都会自动要求回复更精简、更白话（装了 Codex 的话也会一起套用）；代码、指令、路径和错误信息不会被缩减。下次开新对话即生效。",
     "terse_mode_disabled_msg": "已关闭。开新对话时不再自动要求精简回复。",
     "resume_enabled_restart": "已开启。以后开新的 Claude Code 对话，会自动记得这个项目上次做到哪——画面上不会有提示（这是正常的），但 Claude 已经知道。下次开新对话即生效。",
@@ -1716,7 +1716,7 @@
     "claude_beginner_disabled_msg": "已关闭新手模式。重启 Claude Code 后生效。",
     "claude_beginner_action_failed": "无法切换新手模式",
     "quota_aware_menu": "额度感知模式",
-    "quota_aware_tooltip": "额度快用完时，Claude 开大任务前会先告诉你还剩多少、几点重置，让你选先做小的还是等重置。",
+    "quota_aware_tooltip": "额度快用完时，Claude 开大任务前会先告诉你还剩多少、几点重置，让你选先做小的还是等重置。Claude Code 或 Codex 官方服务出状况时，也会告诉 Claude。每个对话开始时，也会给 Claude 一份各家额度的简短总览。",
     "quota_aware_enabled_msg": "已开启额度感知模式。请重启 Claude Code 应用。",
     "quota_aware_disabled_msg": "已关闭额度感知模式。请重启 Claude Code 应用。",
     "quota_aware_action_failed": "无法切换额度感知模式。",
@@ -2078,8 +2078,8 @@
     "project_butler_tooltip": "新規セッションを開くと、前回の進捗を自動で AI に引き継ぎます。説明し直す必要はありません。",
     "terse_mode_menu": "トークン節約モード",
     "terse_mode_tooltip": "新規セッションを開くと、Claude に短めで平易な言葉での返答を自動で求めて出力 token を節約します（Codex を導入済みならそちらにも適用されます）。コード、コマンド、パス、エラーメッセージは省略しません。その後もあなたが送る各メッセージで、簡潔さを保つよう軽く念押しされます。",
-    "terse_reminder_instruction": "[簡潔モードは引き続き有効：この返信は簡潔に、平易な言葉で；コード、コマンド、パス、エラーメッセージは一字そのまま；セキュリティ警告と不可逆操作の確認は引き続き完全に記述すること；ユーザーが明確に詳しい解説を求めた場合は、その要求を優先してください。]",
-    "terse_mode_instruction": "（この会話では「簡潔モード」が有効です。最初の返信の冒頭でこのことに触れてください——すでに他の挨拶（進捗の引き継ぎなど）を述べる予定がある場合は、「簡潔モードが有効」であることをその挨拶に自然に組み込み、別の行を追加しないでください。組み込める挨拶がない場合は、自分で一行「🐾 簡潔モードが有効になりました。返答は短くしていきます！」と述べてください。会話全体に適用されます。前置き、丁寧すぎる言い回し、重複した表現、不必要なつなぎ文を省き、短文や箇条書きで済むなら長い段落に広げないでください。言葉は短い方を選んでください（例:「修正」であって「この問題に対する解決策を実装する」ではない）。簡潔さは予算、平易な言葉はスタイルです。短いからといって難解であってはなりません。専門用語よりも日常的な言葉を選んでください（例：「先に永続化する」ではなく「先に保存する」）。どうしても専門用語が必要な場合は、最初の使用時に10文字以内で平易な説明を補足し、以後はそのまま使用してください。ツールやサブエージェントの出力をそのまま貼り付けないこと。まず理解し、平易な言葉で結論として書き直す。原文のまま残すのはコード、コマンド、パス、エラーメッセージだけ。比喩は不要です。名詞化は動詞に戻す（修正を行う→修正する）。予告だけの文は削る（「これから説明します」「注目すべきは」）。各文は既知が先、新情報が後。一文に一つの内容だけ、一文はおおむね40字以内。能動態で書く（「キーはプログラムによって送られる」ではなく「プログラムがキーを送る」）。同じものには最後まで同じ語を使う（一度「hook」と呼んだら「フック関数」に言い換えない）。最後は、何をしたか、成功したか、次に何をするかの3点だけで締めくくってください。装飾的な表は不要です。冒頭の挨拶を除き、本文に絵文字は入れないでください。ツール名や呼び出し過程の実況は不要ですが、ツールを使う前に何をするかを一言添えるのは構いません。独自の省略語は作らないでください（例:「設定」を「設」に略すなど）——トークナイザー上は完全な語と同じ長さになり、何も節約にならず読み手が余計に解読する手間が増えるだけなので、完全な語のままの方が得です。コード、コマンド、ファイルパス、エラーメッセージは一文字たりとも省略・書き換えしないこと。セキュリティ警告、不可逆操作の確認、接続詞を省くと誤読の恐れがある複数手順の説明では、簡潔さより先に完全な文で明確に伝え、伝え終えたら簡潔モードに戻ってください。ユーザーが明確に詳しい解説や段階的な説明を求めた場合、または状況的に十分な推論が必要な場合は、その要求を優先し、このモードのために重要な情報を落とさないでください。）",
+    "terse_reminder_instruction": "[簡潔モードは引き続き有効：この返信は簡潔に、平易な言葉で、一度読めば分かるように；コード、コマンド、パス、エラーメッセージは一字そのまま；セキュリティ警告と不可逆操作の確認は引き続き完全に記述すること；ユーザーが明確に詳しい解説を求めた場合は、その要求を優先してください。]",
+    "terse_mode_instruction": "（この会話では「簡潔モード」が有効です。最初の返信の冒頭でこのことに触れてください——すでに他の挨拶（進捗の引き継ぎなど）を述べる予定がある場合は、「簡潔モードが有効」であることをその挨拶に自然に組み込み、別の行を追加しないでください。組み込める挨拶がない場合は、自分で一行「🐾 簡潔モードが有効になりました。返答は短くしていきます！」と述べてください。会話全体に適用されます。前置き、丁寧すぎる言い回し、重複した表現、不必要なつなぎ文を省き、短文や箇条書きで済むなら長い段落に広げないでください。言葉は短い方を選んでください（例:「修正」であって「この問題に対する解決策を実装する」ではない）。簡潔さは予算、平易な言葉はスタイルです。短いからといって難解であってはなりません。削ってよいのは、読み返さずに一度で分かるところまでです。AI っぽい文章の多くは、そこを越えて削ることから生まれます。次の語を予想しやすくする：語の組み合わせはよくあるものを使う。物に人間しかしない動作をさせない（「キャッシュが嘘をついている」ではなく「キャッシュに古いデータが残っている」）。エンパワー、ソリューション、シームレスのようなバズワードは使わない。誤解を本当に正すとき以外は、「これは X ではなく Y です」という反転の言い回しを使わない。一度に多くを覚えさせない：主語と述語を近づけ、名詞の前の長い修飾語は次の文に分ける。名詞を積み重ねない（「キャッシュ失効処理機構調整」ではなく「キャッシュが切れた後の処理を直す」）。「なので、だから、でも、もし」のような関係を示す語は、字数を減らすために削らない。専門用語よりも日常的な言葉を選んでください（例：「先に永続化する」ではなく「先に保存する」）。どうしても専門用語が必要な場合は、最初の使用時に10文字以内で平易な説明を補足し、以後はそのまま使用してください。ツールやサブエージェントの出力をそのまま貼り付けないこと。まず理解し、平易な言葉で結論として書き直す。原文のまま残すのはコード、コマンド、パス、エラーメッセージだけ。比喩は不要です。名詞化は動詞に戻す（修正を行う→修正する）。予告だけの文は削る（「これから説明します」「注目すべきは」）。各文は既知が先、新情報が後。一文に一つの内容だけ、一文はおおむね40字以内。能動態で書く（「キーはプログラムによって送られる」ではなく「プログラムがキーを送る」）。同じものには最後まで同じ語を使う（一度「hook」と呼んだら「フック関数」に言い換えない）。最後は、何をしたか、成功したか、次に何をするかの3点だけで締めくくってください。装飾的な表は不要です。冒頭の挨拶を除き、本文に絵文字は入れないでください。ツール名や呼び出し過程の実況は不要ですが、ツールを使う前に何をするかを一言添えるのは構いません。独自の省略語は作らないでください（例:「設定」を「設」に略すなど）——トークナイザー上は完全な語と同じ長さになり、何も節約にならず読み手が余計に解読する手間が増えるだけなので、完全な語のままの方が得です。コード、コマンド、ファイルパス、エラーメッセージは一文字たりとも省略・書き換えしないこと。セキュリティ警告、不可逆操作の確認、接続詞を省くと誤読の恐れがある複数手順の説明では、簡潔さより先に完全な文で明確に伝え、伝え終えたら簡潔モードに戻ってください。ユーザーが明確に詳しい解説や段階的な説明を求めた場合、または状況的に十分な推論が必要な場合は、その要求を優先し、このモードのために重要な情報を落とさないでください。）",
     "terse_mode_enabled_msg": "有効化しました。今後、新しい Claude Code セッションでは返答をより簡潔で平易な言葉にするよう自動で求めます（Codex を導入済みならそちらにも適用されます）。コード、コマンド、パス、エラーメッセージは省略しません。次回セッション開始時に反映されます。",
     "terse_mode_disabled_msg": "無効化しました。新規セッションで簡潔な返答を自動要求しなくなります。",
     "resume_enabled_restart": "有効化しました。今後、新しい Claude Code セッションを開くと、このプロジェクトで前回どこまで進めたかを自動的に把握します。画面に通知は出ません（正常です）が、Claude は把握しています。次回セッション開始時に反映されます。",
@@ -2296,7 +2296,7 @@
     "claude_beginner_disabled_msg": "初心者モードを無効にしました。Claude Code を再起動してください。",
     "claude_beginner_action_failed": "初心者モードを切り替えられません",
     "quota_aware_menu": "クォータ認識モード",
-    "quota_aware_tooltip": "クォータが少なくなると、大きなタスクを始める前に Claude が残量とリセット時刻を伝えます。小さな部分を先に進めるか、リセットを待つか選べます。",
+    "quota_aware_tooltip": "クォータが少なくなると、大きなタスクを始める前に Claude が残量とリセット時刻を伝えます。小さな部分を先に進めるか、リセットを待つか選べます。Claude Code または Codex の公式サービスに障害が起きたときも Claude に伝えます。会話の開始時にも、各ツールのクォータの短い概要を Claude に伝えます。",
     "quota_aware_enabled_msg": "クォータ認識モードを有効にしました。Claude Code を再起動してください。",
     "quota_aware_disabled_msg": "クォータ認識モードを無効にしました。Claude Code を再起動してください。",
     "quota_aware_action_failed": "クォータ認識モードを切り替えられませんでした。",
@@ -2658,8 +2658,8 @@
     "project_butler_tooltip": "새 세션을 열 때 지난 진행 상황을 AI에게 자동으로 전달합니다. 처음부터 다시 설명할 필요 없어요.",
     "terse_mode_menu": "토큰 절약 모드",
     "terse_mode_tooltip": "새 세션을 열 때 Claude에게 더 짧고 쉬운 말로 답하도록 자동으로 요청해 출력 token을 아낍니다 (Codex가 설치되어 있으면 그쪽에도 적용됩니다). 코드, 명령어, 경로, 오류 메시지는 줄이지 않습니다. 이후 보내는 각 메시지에서도 간결함을 유지하도록 가볍게 다시 일러줍니다.",
-    "terse_reminder_instruction": "[간결 모드 계속 적용 중: 이 답변은 짧게, 쉬운 말로; 코드, 명령어, 경로, 오류 메시지는 한 글자 그대로; 보안 경고와 되돌릴 수 없는 작업 확인은 여전히 완전히 적을 것; 사용자가 자세한 설명이나 단계별 안내를 명확히 요청했다면 그 요구를 우선하세요.]",
-    "terse_mode_instruction": "(이 대화에는 '간결 모드'가 켜져 있습니다. 첫 답변 맨 앞에서 이 사실을 언급하세요 — 이미 다른 인사(예: 진행 상황 인수인계)를 할 예정이라면, '간결 모드가 켜졌다'는 내용을 그 인사에 자연스럽게 합쳐서 한 줄로 말하고 따로 추가하지 마세요. 합칠 인사가 없다면 직접 한 줄로 \"🐾 간결 모드를 켰어요. 답변을 짧게 이어갈게요!\"라고 말하세요. 대화 전체에 적용됩니다. 빈말, 지나친 격식, 반복되는 서두, 불필요한 연결 문장은 덜어내고, 짧은 문장이나 목록으로 충분하면 긴 단락으로 늘이지 마세요. 단어는 짧은 쪽을 고르세요 (예: \"이 문제에 대한 해결책을 구현하다\" 대신 \"고치다\"). 간결함은 예산이고, 쉬운 말은 스타일입니다. 짧다고 해서 이해하기 어려워서는 안 됩니다. 전문 용어보다 일상적인 단어를 고르세요(예: \"먼저 영속화하다\" 대신 \"먼저 저장하다\"). 전문 용어를 꼭 써야 한다면, 처음 사용할 때 10글자 이내로 쉬운 설명을 덧붙이고 그 뒤로는 그냥 쓰세요. 도구나 서브에이전트의 출력을 그대로 붙여넣지 말 것: 먼저 이해한 뒤 쉬운 말로 결론으로 다시 쓰고, 코드·명령어·경로·오류 메시지만 원문 그대로 둔다. 비유는 빼주세요. 명사화는 동사로 (수정을 진행한다 → 고친다). 예고만 하는 문장은 삭제 (\"이제 설명하겠습니다\", \"주목할 점은\"). 각 문장은 아는 것 먼저, 새 정보 나중. 한 문장에는 한 가지 내용만, 문장은 대략 40자 이내로. 능동문으로 쓰세요 (\"키가 프로그램에 의해 전송된다\" 대신 \"프로그램이 키를 보낸다\"). 같은 대상은 끝까지 같은 단어로 부르세요 (한 번 \"hook\"이라고 했으면 \"훅 함수\"로 바꾸지 않기). 마무리는 무엇을 했는지, 성공했는지, 다음에 무엇을 할 것인지 이 3가지만 적으세요. 장식용 표는 넣지 마세요. 첫 인사말을 제외하면 본문에 이모지는 넣지 마세요. 도구 이름이나 호출 과정을 중계할 필요는 없지만, 도구를 쓰기 전에 무엇을 할지 한 줄로 말하는 것은 괜찮습니다. 임의로 줄임말을 만들지 마세요 (예: \"설정\"을 \"설\"로 줄이는 식) — 토크나이저 상으로는 완전한 단어와 길이가 같아서 절약되는 게 없고 읽는 사람만 더 해석해야 하니, 완전한 단어를 쓰는 편이 더 낫습니다. 코드, 명령어, 파일 경로, 오류 메시지는 한 글자도 생략하거나 바꾸면 안 됩니다. 보안 경고, 되돌릴 수 없는 작업의 확인, 접속사를 생략하면 오독 위험이 있는 다단계 설명에서는 간결함보다 먼저 완전하고 명확하게 전달한 뒤, 전달이 끝나면 다시 간결 모드로 돌아가세요. 사용자가 자세한 설명이나 단계별 안내를 명확히 요청했거나, 상황상 충분한 추론이 꼭 필요하다면 그 요구를 우선하고, 이 모드 때문에 핵심 정보를 빼먹지 마세요.)",
+    "terse_reminder_instruction": "[간결 모드 계속 적용 중: 이 답변은 짧게, 쉬운 말로, 한 번 읽으면 이해되게; 코드, 명령어, 경로, 오류 메시지는 한 글자 그대로; 보안 경고와 되돌릴 수 없는 작업 확인은 여전히 완전히 적을 것; 사용자가 자세한 설명이나 단계별 안내를 명확히 요청했다면 그 요구를 우선하세요.]",
+    "terse_mode_instruction": "(이 대화에는 '간결 모드'가 켜져 있습니다. 첫 답변 맨 앞에서 이 사실을 언급하세요 — 이미 다른 인사(예: 진행 상황 인수인계)를 할 예정이라면, '간결 모드가 켜졌다'는 내용을 그 인사에 자연스럽게 합쳐서 한 줄로 말하고 따로 추가하지 마세요. 합칠 인사가 없다면 직접 한 줄로 \"🐾 간결 모드를 켰어요. 답변을 짧게 이어갈게요!\"라고 말하세요. 대화 전체에 적용됩니다. 빈말, 지나친 격식, 반복되는 서두, 불필요한 연결 문장은 덜어내고, 짧은 문장이나 목록으로 충분하면 긴 단락으로 늘이지 마세요. 단어는 짧은 쪽을 고르세요 (예: \"이 문제에 대한 해결책을 구현하다\" 대신 \"고치다\"). 간결함은 예산이고, 쉬운 말은 스타일입니다. 짧다고 해서 이해하기 어려워서는 안 됩니다. 줄여도 되는 한계는 다시 읽지 않고 한 번에 이해되는 데까지입니다. AI 같은 글은 흔히 그 한계를 넘어 줄이는 데서 생깁니다. 다음 단어를 예측할 수 있게 쓰세요: 단어는 흔히 쓰는 조합으로 쓰고, 사물에게 사람만 하는 행동을 시키지 마세요(\"캐시가 거짓말을 한다\" 대신 \"캐시에 오래된 데이터가 남아 있다\"). 시너지, 솔루션, 레버리지 같은 유행어는 쓰지 말고, 정말 오해를 바로잡을 때가 아니면 \"이것은 X가 아니라 Y입니다\" 식의 뒤집는 문장도 쓰지 마세요. 한 번에 너무 많이 기억하게 하지 마세요: 주어와 서술어를 가깝게 두고, 명사 앞의 긴 수식어는 다음 문장으로 나누세요. 명사를 줄줄이 쌓지 마세요(\"캐시 만료 처리 메커니즘 조정\" 대신 \"캐시가 만료된 뒤 처리 방식을 고치다\"). \"왜냐하면, 그래서, 하지만, 만약\" 같은 관계를 알려 주는 말은 글자 수를 줄이려고 빼지 마세요. 전문 용어보다 일상적인 단어를 고르세요(예: \"먼저 영속화하다\" 대신 \"먼저 저장하다\"). 전문 용어를 꼭 써야 한다면, 처음 사용할 때 10글자 이내로 쉬운 설명을 덧붙이고 그 뒤로는 그냥 쓰세요. 도구나 서브에이전트의 출력을 그대로 붙여넣지 말 것: 먼저 이해한 뒤 쉬운 말로 결론으로 다시 쓰고, 코드·명령어·경로·오류 메시지만 원문 그대로 둔다. 비유는 빼주세요. 명사화는 동사로 (수정을 진행한다 → 고친다). 예고만 하는 문장은 삭제 (\"이제 설명하겠습니다\", \"주목할 점은\"). 각 문장은 아는 것 먼저, 새 정보 나중. 한 문장에는 한 가지 내용만, 문장은 대략 40자 이내로. 능동문으로 쓰세요 (\"키가 프로그램에 의해 전송된다\" 대신 \"프로그램이 키를 보낸다\"). 같은 대상은 끝까지 같은 단어로 부르세요 (한 번 \"hook\"이라고 했으면 \"훅 함수\"로 바꾸지 않기). 마무리는 무엇을 했는지, 성공했는지, 다음에 무엇을 할 것인지 이 3가지만 적으세요. 장식용 표는 넣지 마세요. 첫 인사말을 제외하면 본문에 이모지는 넣지 마세요. 도구 이름이나 호출 과정을 중계할 필요는 없지만, 도구를 쓰기 전에 무엇을 할지 한 줄로 말하는 것은 괜찮습니다. 임의로 줄임말을 만들지 마세요 (예: \"설정\"을 \"설\"로 줄이는 식) — 토크나이저 상으로는 완전한 단어와 길이가 같아서 절약되는 게 없고 읽는 사람만 더 해석해야 하니, 완전한 단어를 쓰는 편이 더 낫습니다. 코드, 명령어, 파일 경로, 오류 메시지는 한 글자도 생략하거나 바꾸면 안 됩니다. 보안 경고, 되돌릴 수 없는 작업의 확인, 접속사를 생략하면 오독 위험이 있는 다단계 설명에서는 간결함보다 먼저 완전하고 명확하게 전달한 뒤, 전달이 끝나면 다시 간결 모드로 돌아가세요. 사용자가 자세한 설명이나 단계별 안내를 명확히 요청했거나, 상황상 충분한 추론이 꼭 필요하다면 그 요구를 우선하고, 이 모드 때문에 핵심 정보를 빼먹지 마세요.)",
     "terse_mode_enabled_msg": "활성화했습니다. 이제 새 Claude Code 세션에서는 더 간결하고 쉬운 말로 답하도록 자동으로 요청합니다 (Codex가 설치되어 있으면 그쪽에도 적용됩니다). 코드, 명령어, 경로, 오류 메시지는 줄이지 않습니다. 다음 세션 시작 시 적용됩니다.",
     "terse_mode_disabled_msg": "비활성화했습니다. 새 세션에서 더 이상 간결한 답변을 자동 요청하지 않습니다.",
     "resume_enabled_restart": "활성화했습니다. 이제 새 Claude Code 세션을 시작하면 이 프로젝트에서 지난번에 어디까지 했는지 자동으로 파악합니다. 화면에는 안내가 표시되지 않지만(정상입니다) Claude는 알고 있습니다. 다음 세션 시작 시 적용됩니다.",
@@ -2876,7 +2876,7 @@
     "claude_beginner_disabled_msg": "초보자 모드를 껐습니다. Claude Code를 다시 시작하세요.",
     "claude_beginner_action_failed": "초보자 모드를 전환할 수 없습니다",
     "quota_aware_menu": "할당량 인식 모드",
-    "quota_aware_tooltip": "할당량이 부족해지면 Claude가 큰 작업을 시작하기 전에 남은 양과 초기화 시간을 알려 줍니다. 작은 부분을 먼저 진행하거나 초기화를 기다릴 수 있습니다.",
+    "quota_aware_tooltip": "할당량이 부족해지면 Claude가 큰 작업을 시작하기 전에 남은 양과 초기화 시간을 알려 줍니다. 작은 부분을 먼저 진행하거나 초기화를 기다릴 수 있습니다. Claude Code 또는 Codex 공식 서비스에 장애가 생겨도 Claude에게 알려 줍니다. 대화가 시작될 때도 Claude에게 각 도구의 할당량을 간단히 요약해 줍니다.",
     "quota_aware_enabled_msg": "할당량 인식 모드를 켰습니다. Claude Code를 다시 시작해 주세요.",
     "quota_aware_disabled_msg": "할당량 인식 모드를 껐습니다. Claude Code를 다시 시작해 주세요.",
     "quota_aware_action_failed": "할당량 인식 모드를 변경할 수 없습니다.",

{usage_cli-0.34.15 → usage_cli-0.34.17}/installer/session_hooks.py

@@ -74,7 +74,7 @@ _RESUME_DIAGNOSIS_CAUSE_KEYS = (
 )
 TERSE_HOOK_TARGET = Path(os.path.expanduser("~/.claude/usage-terse-mode.py"))
 TERSE_PROMPT_SIDECAR = Path(os.path.expanduser("~/.claude/usage-terse-prompt.json"))
-TERSE_HOOK_VERSION = "1.7"
+TERSE_HOOK_VERSION = "1.8"
 TERSE_MATCHER = "startup|clear"
 TERSE_LANGS = ("zh-TW", "zh-CN", "en", "ja", "ko")
 _TERSE_MARKER = "usage-terse-mode"
@@ -89,13 +89,13 @@ _FEATURES_HOOKS_REGEX = re.compile(r"(?m)^[ \t]*hooks\s*=\s*[A-Za-z0-9_]+")
 # terse hook. Re-injects a one-line nudge on every prompt so the terse style holds across a
 # long conversation. Claude Code only — Codex CLI has no UserPromptSubmit equivalent.
 TERSE_REMINDER_HOOK_TARGET = Path(os.path.expanduser("~/.claude/usage-terse-reminder.py"))
-TERSE_REMINDER_HOOK_VERSION = "1.2"
+TERSE_REMINDER_HOOK_VERSION = "1.3"
 TERSE_REMINDER_MATCHER = ""
 _TERSE_REMINDER_MARKER = "usage-terse-reminder"
 _TERSE_REMINDER_MARKERS = (_TERSE_REMINDER_MARKER, "usage_terse_reminder")
 # Independent, opt-in Claude Code UserPromptSubmit hook.
 QUOTA_AWARE_HOOK_TARGET = Path(os.path.expanduser("~/.claude/usage-quota-aware.py"))
-QUOTA_AWARE_HOOK_VERSION = "1.5"
+QUOTA_AWARE_HOOK_VERSION = "1.12"
 QUOTA_AWARE_MATCHER = ""
 _QUOTA_AWARE_MARKER = "usage-quota-aware"
 _QUOTA_AWARE_MARKERS = (_QUOTA_AWARE_MARKER, "usage_quota_aware")

{usage_cli-0.34.15 → usage_cli-0.34.17}/loaders/agy_quota_probe.py

@@ -15,12 +15,15 @@ the internal ``retrieveUserQuotaSummary`` endpoint for the quota summary.
 
 from __future__ import annotations
 
+import hashlib
 import json
+import math
 import os
 import platform
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 import urllib.parse
 from base64 import b64decode
@@ -41,7 +44,9 @@ from usage_common.subprocess_utils import hidden_console_kwargs
 
 CACHE_PATH = Path(os.path.expanduser("~/.usage/agy_quota_cache.json"))
 AUTH_EXPIRED_PATH = CACHE_PATH.parent / "agy_auth_expired"
+CLI_SIGNED_OUT_PATH = CACHE_PATH.parent / "agy_cli_signed_out"
 _CLI_LOG_PATH = CACHE_PATH.parent / "agy_usage_cli.log"
+BACKGROUND_AGY_LOCK = threading.Lock()
 
 
 def auth_expired() -> bool:
@@ -54,6 +59,38 @@ def _mark_auth_expired() -> None:
         AUTH_EXPIRED_PATH.touch()
 
 
+def mark_cli_signed_out(before: str | None) -> None:
+    after = _credential_fingerprint()
+    if after != before:
+        return
+    with suppress(OSError):
+        CLI_SIGNED_OUT_PATH.parent.mkdir(parents=True, exist_ok=True)
+        CLI_SIGNED_OUT_PATH.write_text(
+            json.dumps({"fingerprint": after, "marked_at": time.time()}),
+            encoding="utf-8",
+        )
+
+
+def agy_cli_signed_in(timeout: float) -> bool:
+    """Open the gate for a readable credential; bypass cooldown only for a known change."""
+    global _cli_retry_after_monotonic
+    if not CLI_SIGNED_OUT_PATH.exists():
+        return True
+    try:
+        marker = json.loads(CLI_SIGNED_OUT_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError, UnicodeError):
+        marker = {}
+    stored = marker.get("fingerprint") if isinstance(marker, dict) else None
+    current = _credential_fingerprint()
+    if current is None or current == stored:
+        return False
+    with suppress(OSError):
+        CLI_SIGNED_OUT_PATH.unlink(missing_ok=True)
+    if isinstance(stored, str):
+        _cli_retry_after_monotonic = 0.0
+    return True
+
+
 # Legacy OAuth token written by older Antigravity CLI versions. Read-only: we
 # never write back here (that is the CLI's home and could corrupt its login).
 _TOKEN_PATH = Path(os.path.expanduser("~/.gemini/antigravity-cli/antigravity-oauth-token"))
@@ -121,6 +158,8 @@ class AgyQuotaGroup:
     models: list[str]
     weekly: AgyQuotaWindow | None
     five_hour: AgyQuotaWindow | None
+    weekly_fetched_at: str | None = None
+    weekly_resets_at: str | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -169,19 +208,40 @@ def _probe_via_cli(timeout: float) -> AgyQuotaResult | None:
     agy = find_agy()
     if agy is None:
         return None
-    if time.monotonic() < _cli_retry_after_monotonic:
-        return None
-    # Offline (e.g. just after a sleep wake) the CLI would open a browser sign-in page.
-    if not google_auth_reachable():
+    if not BACKGROUND_AGY_LOCK.acquire(blocking=False):
         return None
-    result = _run_usage_command(agy, timeout)
-    _cli_retry_after_monotonic = (
-        0.0 if result is not None else time.monotonic() + _CLI_FAILURE_COOLDOWN_SECONDS
-    )
-    return result
+    try:
+        if not agy_cli_signed_in(timeout) or time.monotonic() < _cli_retry_after_monotonic:
+            return None
+        # Offline, the CLI would open a browser sign-in page.
+        if not google_auth_reachable():
+            return None
+        before = _credential_fingerprint()
+        log_offset = 0
+        with suppress(OSError):
+            log_offset = _CLI_LOG_PATH.stat().st_size
+        result = _run_usage_command(agy, timeout, before)
+        if result is None:
+            with suppress(OSError):
+                with _CLI_LOG_PATH.open("rb") as log:
+                    size = log.seek(0, os.SEEK_END)
+                    start = log_offset if size >= log_offset else 0
+                    log.seek(max(start, size - 65536))
+                    tail = log.read()
+                if (
+                    b"Print mode: not authenticated" in tail
+                    or b"triggering interactive OAuth" in tail
+                ):
+                    mark_cli_signed_out(before)
+        _cli_retry_after_monotonic = (
+            0.0 if result is not None else time.monotonic() + _CLI_FAILURE_COOLDOWN_SECONDS
+        )
+        return result
+    finally:
+        BACKGROUND_AGY_LOCK.release()
 
 
-def _run_usage_command(agy: str, timeout: float) -> AgyQuotaResult | None:
+def _run_usage_command(agy: str, timeout: float, before: str | None) -> AgyQuotaResult | None:
     command = [agy, "-p", "/usage", "--output-format", "json", "--log-file", str(_CLI_LOG_PATH)]
     try:
         completed = subprocess.run(
@@ -193,8 +253,19 @@ def _run_usage_command(agy: str, timeout: float) -> AgyQuotaResult | None:
             env=cli_env(agy),
             **hidden_console_kwargs(),
         )
+    except subprocess.TimeoutExpired as exc:
+        if "Authentication required" in str(exc.stdout) or "Authentication required" in str(
+            exc.stderr
+        ):
+            mark_cli_signed_out(before)
+        return None
     except (OSError, subprocess.SubprocessError):
         return None
+    if "Authentication required" in str(completed.stdout) or "Authentication required" in str(
+        getattr(completed, "stderr", "")
+    ):
+        mark_cli_signed_out(before)
+        return None
     if completed.returncode != 0:
         return None
     try:
@@ -226,11 +297,57 @@ def load_quota(max_age_minutes: float = 5) -> AgyQuotaResult | None:
     probed = probe_quota()
     if probed is None:
         return cached
+    probed = _carry_missing_weekly(probed, cached)
     probed = _carry_missing_groups(probed, cached)
     _write_cache(probed)
     return probed
 
 
+def _carry_missing_weekly(probed: AgyQuotaResult, cached: AgyQuotaResult | None) -> AgyQuotaResult:
+    """Retain a missing weekly window until its cached reset, without refreshing its age."""
+    if cached is None:
+        return probed
+    cached_at = _parse_timestamp(cached.fetched_at)
+    probed_at = _parse_timestamp(probed.fetched_at)
+    if cached_at is None or probed_at is None:
+        return probed
+    previous = {group.name: group for group in cached.groups}
+    groups = []
+    for group in probed.groups:
+        old = previous.get(group.name)
+        window = old.weekly if old is not None else None
+        if (
+            group.weekly is None
+            and old is not None
+            and window is not None
+            and window.resets_in_minutes is not None
+        ):
+            resets_at = (
+                _parse_timestamp(old.weekly_resets_at)
+                if old.weekly_resets_at is not None
+                else cached_at + timedelta(minutes=window.resets_in_minutes)
+            )
+            if resets_at is not None and resets_at > probed_at:
+                minutes = max(0, math.ceil((resets_at - probed_at).total_seconds() / 60))
+                group = replace(
+                    group,
+                    weekly=replace(
+                        window, resets_in_minutes=minutes, resets_in=_format_resets_in(minutes)
+                    ),
+                    weekly_fetched_at=old.weekly_fetched_at or cached.fetched_at,
+                    weekly_resets_at=resets_at.isoformat(),
+                )
+        groups.append(group)
+    return replace(probed, groups=groups)
+
+
+def _age_window(window: AgyQuotaWindow | None, elapsed: int) -> AgyQuotaWindow | None:
+    if window is None or window.resets_in_minutes is None or elapsed == 0:
+        return window
+    minutes = max(0, window.resets_in_minutes - elapsed)
+    return replace(window, resets_in_minutes=minutes, resets_in=_format_resets_in(minutes))
+
+
 def _carry_missing_groups(probed: AgyQuotaResult, cached: AgyQuotaResult | None) -> AgyQuotaResult:
     """Keep a group the API skipped this once, so the group toggle has something to show.
 
@@ -261,14 +378,12 @@ def _carry_missing_groups(probed: AgyQuotaResult, cached: AgyQuotaResult | None)
         else 0
     )
 
-    def age_window(window: AgyQuotaWindow | None) -> AgyQuotaWindow | None:
-        if window is None or window.resets_in_minutes is None or elapsed == 0:
-            return window
-        minutes = max(0, window.resets_in_minutes - elapsed)
-        return replace(window, resets_in_minutes=minutes, resets_in=_format_resets_in(minutes))
-
     missing = [
-        replace(group, weekly=age_window(group.weekly), five_hour=age_window(group.five_hour))
+        replace(
+            group,
+            weekly=_age_window(group.weekly, elapsed),
+            five_hour=_age_window(group.five_hour, elapsed),
+        )
         for group in missing
     ]
     order = {group.name: index for index, group in enumerate(cached.groups)}
@@ -276,6 +391,21 @@ def _carry_missing_groups(probed: AgyQuotaResult, cached: AgyQuotaResult | None)
     return AgyQuotaResult(groups=groups, fetched_at=probed.fetched_at)
 
 
+def _credential_fingerprint() -> str | None:
+    """Hash only the stored credential, without resolving or refreshing a token."""
+    token_data: object = None
+    if sys.platform == "darwin":
+        token_data = _read_macos_credential()
+    if not _has_usable_token(token_data):
+        token_data = _read_token_file()
+    if not _has_usable_token(token_data) and sys.platform == "win32":
+        token_data = _read_windows_credential()
+    token = token_data.get("token") if isinstance(token_data, dict) else None
+    if not isinstance(token, dict):
+        return None
+    return hashlib.sha256(json.dumps(token, sort_keys=True).encode()).hexdigest()
+
+
 def _resolve_access_token(timeout: float) -> str | None:
     """Return a usable access token, refreshing when stale.
 
@@ -845,7 +975,31 @@ def _read_cache() -> AgyQuotaResult | None:
         return None
     except OSError:
         return None
-    return _result_from_payload(payload)
+    result = _result_from_payload(payload)
+    if result is None:
+        return None
+    fetched_at = _parse_timestamp(result.fetched_at)
+    assert fetched_at is not None
+    now = datetime.now(UTC)
+
+    def weekly_expired(group: AgyQuotaGroup) -> bool:
+        if group.weekly_resets_at is not None:
+            resets_at = _parse_timestamp(group.weekly_resets_at)
+            if resets_at is not None:
+                return resets_at <= now
+        return (
+            group.weekly is not None
+            and group.weekly.resets_in_minutes is not None
+            and fetched_at + timedelta(minutes=group.weekly.resets_in_minutes) <= now
+        )
+
+    groups = [
+        replace(group, weekly=None, weekly_fetched_at=None, weekly_resets_at=None)
+        if group.weekly_fetched_at is not None and weekly_expired(group)
+        else group
+        for group in result.groups
+    ]
+    return replace(result, groups=groups)
 
 
 def _write_cache(result: AgyQuotaResult) -> None:
@@ -874,6 +1028,12 @@ def _result_to_payload(result: AgyQuotaResult) -> dict[str, object]:
                 "models": group.models,
                 "weekly": _window_to_payload(group.weekly),
                 "five_hour": _window_to_payload(group.five_hour),
+                **(
+                    {"weekly_fetched_at": group.weekly_fetched_at}
+                    if group.weekly_fetched_at
+                    else {}
+                ),
+                **({"weekly_resets_at": group.weekly_resets_at} if group.weekly_resets_at else {}),
             }
             for group in result.groups
         ],
@@ -917,6 +1077,8 @@ def _group_from_payload(payload: object) -> AgyQuotaGroup | None:
     models = payload.get("models")
     weekly = _window_from_payload(payload.get("weekly"))
     five_hour = _window_from_payload(payload.get("five_hour"))
+    weekly_fetched_at = payload.get("weekly_fetched_at")
+    weekly_resets_at = payload.get("weekly_resets_at")
     if (
         not isinstance(name, str)
         or not name
@@ -926,9 +1088,29 @@ def _group_from_payload(payload: object) -> AgyQuotaGroup | None:
         or "five_hour" not in payload
         or (payload["weekly"] is not None and weekly is None)
         or (payload["five_hour"] is not None and five_hour is None)
+        or (
+            weekly_fetched_at is not None
+            and (
+                not isinstance(weekly_fetched_at, str)
+                or _parse_timestamp(weekly_fetched_at) is None
+            )
+        )
+        or (
+            weekly_resets_at is not None
+            and (
+                not isinstance(weekly_resets_at, str) or _parse_timestamp(weekly_resets_at) is None
+            )
+        )
     ):
         return None
-    return AgyQuotaGroup(name=name, models=models, weekly=weekly, five_hour=five_hour)
+    return AgyQuotaGroup(
+        name=name,
+        models=models,
+        weekly=weekly,
+        five_hour=five_hour,
+        weekly_fetched_at=weekly_fetched_at,
+        weekly_resets_at=weekly_resets_at,
+    )
 
 
 def _window_from_payload(payload: object) -> AgyQuotaWindow | None:

{usage_cli-0.34.15 → usage_cli-0.34.17}/loaders/codex_disk_cache.py

@@ -116,6 +116,9 @@ def seed_caches(
                 size = file_data["size"]
                 session_id = file_data["session_id"]
                 forked_from_id = file_data["forked_from_id"]
+                is_thread_spawn = file_data["is_thread_spawn"]
+                if not isinstance(is_thread_spawn, bool):
+                    continue
                 entries_data = file_data["entries"]
                 confirmed_offset = int(file_data.get("confirmed_offset", 0))
                 digest_hex = file_data.get("confirmed_prefix_digest", "")
@@ -128,7 +131,11 @@ def seed_caches(
                 file_info_cache[path] = (
                     mtime,
                     size,
-                    _SessionFileInfo(session_id=session_id, forked_from_id=forked_from_id),
+                    _SessionFileInfo(
+                        session_id=session_id,
+                        forked_from_id=forked_from_id,
+                        is_thread_spawn=is_thread_spawn,
+                    ),
                 )
                 if entries_data is None:
                     continue
@@ -184,7 +191,7 @@ def flush_caches(
         shards: list[dict[str, Any]] = [{} for _ in range(_SHARD_COUNT)]
         for path, entry in jsonl_cache.items():
             info = file_info_cache.get(path)
-            if entry.replay_cache_key is not None:
+            if entry.replay_cache_key is not None or (info is not None and info[2].forked_from_id):
                 if info is None:
                     continue
                 entries_data = None
@@ -205,6 +212,7 @@ def flush_caches(
                 "size": entry.size,
                 "session_id": session_id,
                 "forked_from_id": forked_from_id,
+                "is_thread_spawn": info[2].is_thread_spawn if info is not None else False,
                 "entries": entries_data,
                 "confirmed_offset": entry.confirmed_offset,
                 "confirmed_prefix_digest": entry.confirmed_prefix_digest.hex(),