claude-cache-keepalive 0.1.10 → 0.1.11

package/README.md

@@ -139,6 +139,12 @@ Environment variables (mostly for testing / advanced use):
 
 ## Changelog
 
+### 0.1.11
+- **Feature:** opt-in **unattended AI mode** (`cwarm --ai`, or `CWARM_AI=1`, or press `Ctrl+\` anytime to toggle — state persists per project and shows in the statusline). After two keepalive pings with no human keystrokes, cwarm injects a cycling set of safe work instructions (review → tests → docs → …) instead of plain `hi`, pacing itself by your 5h and weekly quota headroom (a bridge file written by the statusline feeds the host live `rate_limits`, since the host process can't see the statusline payload directly). Customize the cycle with `CWARM_AI_MSG` (single message) or `CWARM_AI_MSG_FILE` (one instruction per line, `#` = comment). Statusline also gains an account/plan segment (`👤you·Max 5x`, useful when switching accounts with `/login`) and a 95%-quota warning.
+- **Hardening:** the AI-state and usage-bridge files are now isolated per project directory (they were briefly global during development, which would have let two accounts' quota windows overwrite each other); bracketed-paste and Windows batch-paste content can no longer be misread as the toggle hotkey or counted as "unattended activity"; a mistyped `CWARM_HUMAN_QUIET_S` now falls back to the 5-minute default with a logged warning instead of silently disabling the anti-half-typed-draft guard; the AI instruction cycle advances on its own step counter so a quota-gated pause can't skip steps; the cwd key used for cwarm's own state files only folds case/slashes on Windows, so it can't collapse two distinct directories that differ only by case on a case-sensitive filesystem.
+- **功能：** 選配的**無人值守 AI 模式**（`cwarm --ai`、或 `CWARM_AI=1`、或執行中隨時按 `Ctrl+\` 切換——狀態依專案持久化、statusline 會顯示）。連兩發保溫 `hi` 都沒人碰鍵盤後，第三發起改敲一組循環式安全工作指令（檢視→測試→文件→……）取代單純的 `hi`，並依 5 小時與週額度餘裕自動調節節奏（額度資料由 statusline 落地成橋接檔給 host 讀，因為 host 行程本身收不到 statusline 的 payload）。可用 `CWARM_AI_MSG`（固定一句）或 `CWARM_AI_MSG_FILE`（一行一條指令，`#` 開頭為註解）自訂循環內容。statusline 同時新增帳號/訂閱段位（如 `👤you·Max 5x`，`/login` 切帳號時很好用）與 95% 額度警示。
+- **強化：** AI 狀態檔與額度橋接檔改成依專案目錄各自隔離（開發過程中曾短暫全域共用，會讓兩個帳號的額度視窗互相覆蓋）；bracketed-paste 與 Windows 批次貼上內容不會再被誤判成切換熱鍵或算成「無人值守活動」；`CWARM_HUMAN_QUIET_S` 打錯字時會退回 5 分鐘預設值並記警告，不再靜默關掉防止半句草稿被送出的安全閥；AI 指令循環改用獨立的步進計數器推進，額度閘門暫停期間不會讓循環跳號；cwarm 自家狀態檔使用的路徑鍵只在 Windows 上做大小寫/斜線正規化，避免在大小寫敏感的檔案系統上把兩個真正不同的目錄錯誤地合併成同一份狀態。
+
 ### 0.1.10
 - **Fix:** the optional statusline segment now reflects the 0.1.9 billing guard. On credits/API billing the keepalive is suspended, but the `♻️ cache …` countdown kept ticking as if warming were still active — misleading. The segment now shows `⏸️ cwarm off (API)` while `detectBillingMode` reports credits, and returns to the normal countdown once you're back on a subscription account.
 - **修正：** 選配的 statusline 區段現在會反映 0.1.9 的計費防護。credits／API 計費時 keepalive 已暫停，但 `♻️ cache …` 倒數仍照跑，彷彿還在保溫——會造成誤導。現在 `detectBillingMode` 回報 credits 期間會改顯示 `⏸️ cwarm off (API)`，切回訂閱帳號後自動恢復正常倒數。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cache-keepalive",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Keep Claude Code's prompt cache warm while idle, by running claude inside a PTY host and injecting a tiny keepalive when you step away. Cross-platform, no tmux required.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -12,7 +12,11 @@ if (first === 'setup') {
   printHelp();
   process.exit(0);
 } else {
-  startHost({ args: argv }); // 完全透傳給 claude；不帶參數就是乾淨的 claude（不再隱含 --continue）
+  // `--ai` 是 cwarm 自己的旗標（開啟無人值守 AI 模式），要在透傳前攔掉，其餘原樣給 claude。
+  // filter 在沒有 '--ai' 時本就回傳等價陣列，不必額外用三元式判斷要不要濾。
+  const ai = argv.includes('--ai');
+  const args = argv.filter((a) => a !== '--ai');
+  startHost({ args, ai }); // 完全透傳給 claude；不帶參數就是乾淨的 claude（不再隱含 --continue）
 }
 
 function printHelp() {
@@ -29,6 +33,21 @@ Usage:
 Everything except the 'setup' subcommand is passed straight to claude
 (e.g. \`cwarm --version\`, \`cwarm resume\`, \`cwarm -p "..."\`).
 
+Unattended AI mode (opt-in, off by default):
+  cwarm --ai [claude args]  After two keepalive pings with no human keystrokes,
+                            inject a cycling set of safe work instructions
+                            (review / tests / docs / ...) instead of plain "hi",
+                            pacing itself by your 5h + weekly quota headroom.
+                            Also: CWARM_AI=1, or press Ctrl+\\ anytime to toggle
+                            (state shows in the statusline; CWARM_TOGGLE_KEY=]
+                            etc. rebinds it if your IME steals the default).
+                            The toggle persists across restarts, per project;
+                            --ai / CWARM_AI=0 override the remembered state.
+                            Customize the cycle
+                            with CWARM_AI_MSG (single message) or
+                            CWARM_AI_MSG_FILE (one instruction per line, # = comment)
+                            — the built-in cycle is software-engineering oriented.
+
 Keepalive only fires after you've been idle past the cache-TTL threshold.
 The TTL is auto-detected from the transcript's cache_creation (1h cache ->
 fire after ~58min idle; 5m cache -> ~4min), not guessed from your plan.

package/src/host.mjs

@@ -5,7 +5,7 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { defaultClaudeDir, regimeParams, detectTtlRegime, decideInject, transcriptIdleMs, looksLikeTrustPrompt, detectBillingMode } from './keepalive.mjs';
+import { defaultClaudeDir, regimeParams, detectTtlRegime, decideInject, transcriptIdleMs, looksLikeTrustPrompt, detectBillingMode, readUsageBridge, usageState, looksLikeHumanInput, pickInjectMsg, aiPacing, weeklyGate, readAiMsgFile, aiStatePath, extractAiToggle, clampHumanQuiet, toggleKeySpec, readAiState, initialAiEnabled } from './keepalive.mjs';
 
 const require = createRequire(import.meta.url);
 const isWin = process.platform === 'win32';
@@ -21,6 +21,20 @@ export function resolveClaude() {
   return 'claude'; // 最後手段：交給 node-pty 用 PATH 試
 }
 
+// 讀數字型環境變數：空/未設回 def；非數字（如打錯成 "5m"）回 def 並記警告（不可靜默失效
+// 掉安全機制，如 CWARM_HUMAN_QUIET_S 打錯字就悄悄關掉打字防護）；用 isFinite 而非 `|| def`，
+// 讓合法的 "0"（如使用者故意要 CWARM_AI_FAST_PCT=0 關閉快節奏）不會被 falsy 誤當未設定。
+function envNumber(name, def, log) {
+  const raw = process.env[name];
+  if (raw == null || raw === '') return def;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    if (log) { try { fs.appendFileSync(log, `${new Date().toISOString()} warn: ${name}=${JSON.stringify(raw)} is not a number, using default ${def}\n`); } catch {} }
+    return def;
+  }
+  return n;
+}
+
 // 算出要 spawn 的 (file, args)。Windows 上 .cmd/.bat shim 無法被 node-pty 直接 exec，改用 cmd.exe 包。
 function spawnSpec(claudeBin, args) {
   if (isWin && /\.(cmd|bat)$/i.test(claudeBin)) {
@@ -40,11 +54,14 @@ export function startHost(opts = {}) {
   const args = opts.args || [];
   const { file, args: spawnArgs } = spawnSpec(resolveClaude(), args);
 
+  // 固定取一次 cwd，全程共用（host 不會 chdir）：writeAiState/usage bridge/transcript 查找
+  // 都用同一個值，避免不同時間點呼叫 process.cwd() 理論上不一致、間接影響 cwdKey 對應。
+  const hostCwd = process.cwd();
   const ptyProc = pty.spawn(file, spawnArgs, {
     name: process.env.TERM || 'xterm-256color',
     cols: process.stdout.columns || 80,
     rows: process.stdout.rows || 24,
-    cwd: process.cwd(),
+    cwd: hostCwd,
     env: process.env,
   });
 
@@ -54,7 +71,48 @@ export function startHost(opts = {}) {
   // 終端輸入（捲動／讀回覆／打到一半沒送出）不會刷新 cache，拿來計時會誤判成「使用者還在忙」。
   if (process.stdin.isTTY) { try { process.stdin.setRawMode(true); } catch {} }
   process.stdin.resume();
-  process.stdin.on('data', (d) => { ptyProc.write(d); });
+  // 無人值守 AI 模式總開關：預設關（其他使用者多半只要純保溫）。
+  // 開法三種：`cwarm --ai`、CWARM_AI=1、或執行中按熱鍵隨時切換——預設 Ctrl+\
+  //（Ctrl+] 會被中文輸入法攔成全形】），CWARM_TOGGLE_KEY 可換；
+  //（Unix=裸控制位元組、Windows=win32-input-mode 封包，偵測與剝除都在 extractAiToggle）。
+  // 狀態寫進 cwarm-ai-<cwd>.json（含 ts 心跳、per-cwd 檔名——多 host 並行不互蓋、
+  // key=熱鍵標籤供 statusline 顯示提示），statusline 用 payload 的 cwd 對回同一份。
+  // 初值持久化：Ctrl+\ 切過的狀態記在 per-cwd 狀態檔，重啟沿用（--ai / CWARM_AI 可覆蓋）。
+  let aiEnabled = initialAiEnabled({
+    flagAi: opts.ai,
+    envAi: process.env.CWARM_AI,
+    persisted: readAiState(claudeDir, hostCwd, { maxAgeMs: Infinity }),
+  });
+  const toggleKey = toggleKeySpec(process.env.CWARM_TOGGLE_KEY);
+  function writeAiState() {
+    try { fs.writeFileSync(aiStatePath(claudeDir, hostCwd), JSON.stringify({ enabled: aiEnabled, ts: Date.now(), key: toggleKey.label })); } catch {}
+  }
+  writeAiState();
+
+  // consecInjects：連續注入計數（無人值守偵測用）。人一敲鍵就歸零；判斷含 win32-input-mode
+  // 封包解析（Windows 所有按鍵都以 ESC[..._ 封包送達，不能用「非 ESC 開頭」判人）。
+  // lastHumanMs：使用者最後一次敲鍵時刻——敲鍵後一段時間內（humanQuietMs）絕不注入，
+  // 避免把打到一半的草稿連同 "hi" 一起 Enter 送出。
+  // aiStep：無人值守 18 階段循環的實際位置，只在真的敲出 AI 循環訊息時遞增（見下方 tick）。
+  // 與 consecInjects 分開維護：consecInjects 只用來判定「是否已無人值守」，暫停期間
+  // 送出的普通 "hi" 仍會累加它——若拿它直接當循環索引，暫停恢復後會整段跳號。
+  let consecInjects = 0;
+  let aiStep = 0;
+  let lastHumanMs = 0;
+  process.stdin.on('data', (d) => {
+    const { toggled, rest } = extractAiToggle(d, toggleKey.code);
+    if (toggled) {
+      aiEnabled = !aiEnabled;
+      writeAiState();
+      consecInjects = 0;
+      aiStep = 0;
+      lastHumanMs = Date.now(); // 按熱鍵也是人為活動
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} ai mode ${aiEnabled ? 'ON' : 'OFF'} (${toggleKey.label} toggle)\n`); } catch {}
+    }
+    if (rest.length === 0) return;
+    if (looksLikeHumanInput(rest)) { consecInjects = 0; aiStep = 0; lastHumanMs = Date.now(); }
+    ptyProc.write(rest);
+  });
   // 追蹤 claude 最近一次有輸出到畫面的時刻：閒置在輸入框時畫面靜止；提示等待回答時 spinner 在動、
   // 生成/跑工具時持續輸出。注入前要求畫面已靜止一段時間（見下方 quietMs），就能避開「忙/卡」狀態。
   let lastOutputMs = Date.now();
@@ -81,10 +139,63 @@ export function startHost(opts = {}) {
   if (thr != null) overrides.idleThreshold = Number(thr);
   if (ttlO != null) overrides.ttl = Number(ttlO);
 
-  let lastFire = 0;
+  // reset 後的回溫訊息："go on"（續跑任務）也算 AI 自主行為，未開 AI 模式時只補一般訊息回溫。
+  // 做成函式：Ctrl+] 隨時切換 aiEnabled，用時才取值。
+  const resumeMsg = () => process.env.CWARM_RESUME_MSG || (aiEnabled ? 'go on' : msg);
+  // 無人值守 AI 模式：連兩發 "hi" 都沒人碰鍵盤後，第三發起改敲 12 階段循環工作流，
+  // 讓閒置視窗產生實際價值。設計原則：每步「安全、有界、可驗證」——檢視類在前、
+  // 執行類帶安全閥（不可部署、不可破壞性操作、不可展開大型新工作，對齊全域 SOP）、
+  // 末段自我迭代與收尾報告，使用者回來直接驗收。CWARM_AI_MSG 可覆蓋成固定一句
+  //（設成 "hi" 即等於關掉本模式）。1h 檔位一步一小時，一輪約半天。
+  // 指令用英文（注入訊息本來就是 hi / go on 一路英文，且較省 token）；回覆語言由使用者的
+  // CLAUDE.md 控制，不受注入語言影響。18 階段中文對照：
+  // 檢視段：review → 批判 review → TODO/FIXME 掃描 → 保守建議
+  // 執行段：依建議執行 → 測試覆蓋 → mutation check（測試有效性）→ 錯誤處理稽核 →
+  //         資安自查 → 相依套件體檢（只報告不升級）→ 效能低垂果實 → 小步重構 → 跨平台審視
+  // 收斂段：文件同步 → README 快速上手驗證 → 對照方案探索（防路徑依賴）→
+  //         經驗蒸餾（寫進 memory/CLAUDE.md，複利最高）→ 收尾報告＋決策佇列（睡醒五分鐘拍板解鎖下一天）
+  // 指令來源優先序：CWARM_AI_MSG（固定一句）> CWARM_AI_MSG_FILE（自訂循環，一行一條）> 內建循環。
+  const aiMsg = process.env.CWARM_AI_MSG
+    || readAiMsgFile(process.env.CWARM_AI_MSG_FILE)
+    || [
+    'Unattended: review the work done in this session; briefly list problems and possible improvements.',
+    'Unattended: critical review — challenge earlier assumptions and approaches; point out risks, blind spots, and missing test scenarios.',
+    'Unattended: sweep the code for TODO / FIXME / HACK markers; triage into quick-fix / should-fix / ignore, and fix the quick ones.',
+    'Unattended: based on the findings above, propose a conservative, low-risk improvement list with priorities.',
+    'Unattended: execute the safest suggested items one by one, verifying each. No deploys, no destructive operations, no large new work.',
+    'Unattended: check test coverage — find uncovered branches and edge cases, add the needed tests, run the full suite.',
+    'Unattended: mutation check — mentally (or on a scratch copy) break one small piece of logic and verify existing tests would catch it; where they would not, that coverage is fake — add a real test.',
+    'Unattended: audit error handling — walk the failure paths (bad input, missing files, timeouts, permissions); patch gaps minimally, with tests.',
+    'Unattended: light security self-check — leaked secrets in code/logs, injection risks, over-broad permissions; fix only clear issues.',
+    'Unattended: dependency health check — outdated or vulnerable dependencies (e.g. npm outdated / npm audit); report findings only, do not upgrade.',
+    'Unattended: performance pass — find low-hanging fruit (repeated IO, needless polling, cacheable recomputation); small certain wins only, no big refactors.',
+    'Unattended: small refactors — naming, duplication, readability; behavior must not change, tests guard every step.',
+    'Unattended: cross-platform review — check assumptions about paths, line endings, shells and permissions across Windows/macOS/Linux; list suspicious spots and add guards where clearly needed.',
+    'Unattended: sync docs — check README, comments and usage notes against reality; update stale parts, fill gaps.',
+    'Unattended: verify the README quickstart — follow the install/usage steps literally from scratch and note where documentation and reality diverge; fix the docs.',
+    "Unattended: devil's advocate — pick one design decision made in this session, seriously sketch a different approach, compare trade-offs, and conclude; analysis only, no code changes.",
+    'Unattended: distill lessons — write the non-obvious, durable lessons from this session into project memory / CLAUDE.md so every future session benefits; skip anything already recorded.',
+    'Unattended: wrap up — write a concise report of all changes and open items, plus a decision queue: questions only the user can answer, each with context, options, and your recommendation.',
+  ];
+  // 使用者敲鍵後需靜默這麼久才可注入（預設 5 分鐘）。CWARM_HUMAN_QUIET_S 可調；
+  // 打錯成非數字（如 "5m"）會記警告並退回預設，不會悄悄關掉這個安全機制。
+  const humanQuietMs = envNumber('CWARM_HUMAN_QUIET_S', 300, LOG) * 1000;
+  // startedMs：只認啟動後有寫入的 transcript（Context 0% 不保溫；見 transcriptIdleMs 註解）。
+  // lastFire 也從啟動起算當第二道保險：即使第一句話立刻寫入，仍需滿一個冷卻週期才可能注入。
+  const startedMs = Date.now();
+  let lastFire = startedMs;
   let trustGuardLogged = false;
   let creditsGuardLogged = false;
+  // 額度視窗狀態：撞牆時記下 resets_at 並暫停注入；reset 過後第一發改敲 resumeMsg
+  //（"go on"）——既回溫 cache，又讓被額度打斷的任務自動續跑。資料來自 statusline
+  // 落地的橋接檔（cwarm-usage.json）；95% 提醒由 statusline 顯示，host 不改行為（照用 "hi"）。
+  let limitResetsAt = null;
+  let pendingResume = false;
+  let limitLogged = false;
+  let noUsageWarned = false; // --ai 但讀不到額度橋接檔時警告一次（額度閘門全數失效）
+  let noTranscriptWarned = false; // 啟動夠久了還是找不到本專案 transcript，警告一次（診斷路徑不符等問題）
   const timer = setInterval(() => {
+    writeAiState(); // 心跳：statusline 靠 ts 新鮮度判斷 host 還活著才顯示開關段
     // credits / API 計費（/login 切到 Console 帳號、或只用 ANTHROPIC_API_KEY）時，每次注入
     // 都是實際花錢，保溫沒有意義 → 自動暫停。每個 tick 重新偵測，session 中 /login 切回
     // 訂閱帳號會自動恢復保溫。要強制指定：CWARM_BILLING=subscription|credits。
@@ -110,20 +221,93 @@ export function startHost(opts = {}) {
       return;
     }
     trustGuardLogged = false;
-    const cwd = process.cwd();
-    const regime = detectTtlRegime(claudeDir, cwd);           // 從 transcript 實測 1h/5m，不再猜方案
-    const { ttl, idleThreshold } = regimeParams(regime, overrides);
+    // ---- 額度視窗（5h window）----
+    // 以 hostCwd 為鍵：不同帳號/專案的並行 host 各讀各的橋接檔，不會互相覆蓋額度視窗。
+    const usage = readUsageBridge(claudeDir, hostCwd);
+    // AI 模式的撞牆偵測/週配速/reset 續跑全靠 statusline 落地的橋接檔；沒裝 statusline
+    //（cwarm setup）或 payload 沒有 rate_limits 時所有閘門都是 unknown——明講，別靜默裸奔。
+    if (aiEnabled && usage == null && !noUsageWarned) {
+      noUsageWarned = true;
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} warn: ai mode has no usage data (run \`cwarm setup\` to install the statusline bridge) — quota gates inactive\n`); } catch {}
+    }
+    if (usage != null) noUsageWarned = false;
+    const nowSec = Date.now() / 1000;
+    const ustate = usage ? usageState({ usedPct: usage.usedPct, resetsAt: usage.resetsAt, nowSec }) : 'unknown';
+    if (ustate === 'limited') {
+      limitResetsAt = usage.resetsAt;
+      if (!limitLogged) {
+        limitLogged = true;
+        try { fs.appendFileSync(LOG, `${new Date().toISOString()} skip: usage limit reached (${Math.round(usage.usedPct)}%) — waiting for reset at ${new Date(usage.resetsAt * 1000).toISOString()}\n`); } catch {}
+      }
+      return; // 撞牆期間注入到不了伺服器，暫停等 reset
+    }
+    if (limitResetsAt != null && nowSec > limitResetsAt) {
+      limitResetsAt = null;
+      limitLogged = false;
+      pendingResume = true; // 視窗已重置：下一發改敲 resumeMsg，回溫 cache 兼續跑被打斷的任務
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} window reset — next inject will send "${resumeMsg()}"\n`); } catch {}
+    }
+    const regime = detectTtlRegime(claudeDir, hostCwd);        // 從 transcript 實測 1h/5m，不再猜方案
+    // 週配速：7 天視窗以日均（100/7 ≈ 14.3%/天）攤出進度線，ok=可快跑、slow=退回
+    // 一個 TTL 一步、off=超線一天日均以上 → 暫停 AI 工作只剩純保溫 "hi"。
+    const wgate = weeklyGate({
+      usedPct: usage ? usage.weekPct : null,
+      resetsAt: usage ? usage.weekResetsAt : null,
+      nowSec,
+    });
+    // AI 模式且額度充裕（5h < CWARM_AI_FAST_PCT 預設 70%，且週配速在線內）時改快節奏
+    //（CWARM_AI_PACE_S，預設 5 分），讓 12 階段循環按完工速度推進而不是空等 TTL。
+    const { ttl, idleThreshold } = aiPacing({
+      enabled: aiEnabled,
+      consecInjects,
+      usedPct: usage ? usage.usedPct : null,
+      ustate,
+      weekly: wgate,
+      ...regimeParams(regime, overrides),
+      paceS: envNumber('CWARM_AI_PACE_S', 300, LOG),
+      fastMaxPct: envNumber('CWARM_AI_FAST_PCT', 70, LOG),
+    });
     const now = Date.now();
-    const idleMs = transcriptIdleMs(claudeDir, cwd, now);
+    const idleMs = transcriptIdleMs(claudeDir, hostCwd, now, startedMs);
+    // idleMs 找不到 transcript 時保溫整個靜默失效，且原本沒有任何提示——啟動超過 2 分鐘
+    // （早期本來就會是 null，Context 0% 正常現象，不必吵）仍找不到才警告一次，提示可能是
+    // cwd 與 Claude Code 建立的 transcript 資料夾對不上（磁碟代號大小寫、junction 等）。
+    if (idleMs == null) {
+      if (!noTranscriptWarned && now - startedMs > 120_000) {
+        noTranscriptWarned = true;
+        try { fs.appendFileSync(LOG, `${new Date().toISOString()} warn: no transcript found for this project after 2min — keepalive inactive (check for a cwd / drive-letter mismatch against Claude Code's project folder)\n`); } catch {}
+      }
+    } else if (noTranscriptWarned) {
+      noTranscriptWarned = false;
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} resume: transcript found — keepalive active\n`); } catch {}
+    }
     const screenIdleMs = now - lastOutputMs;
-    if (decideInject({ now, idleMs, lastFire, idleThreshold, ttl, disabled: fs.existsSync(DISABLE), screenIdleMs, quietMs })) {
+    // reset 後若使用者自己先回來發了訊息（transcript 剛更新過），就不必再補 "go on"
+    if (pendingResume && idleMs != null && idleMs < 60_000) {
+      pendingResume = false;
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} resume skipped — user already active after reset\n`); } catch {}
+    }
+    const humanIdleMs = now - lastHumanMs;
+    // humanQuiet 鉗在 idleThreshold-60s 內：short 檔（TTL 300s/門檻 240s）若照吃 300s
+    // 靜默，注入會落在 cache 冷掉之後——保命的提早注入餘裕不能被這個門檻吃掉。
+    const hqMs = clampHumanQuiet(humanQuietMs, idleThreshold);
+    if (decideInject({ now, idleMs, lastFire, idleThreshold, ttl, disabled: fs.existsSync(DISABLE), screenIdleMs, quietMs, humanIdleMs, humanQuietMs: hqMs })) {
       // 先送 Esc：把任何「必答」modal（權限/選單/計畫批准）收掉、退回輸入框，後面那個 Enter 才不會誤選預設項；
       // 空輸入框時 Esc 等同 no-op。隔一小段再送訊息——讓 claude 先把 modal 收乾淨，也避免 ESC 與字元被併成 Meta 鍵。
+      const aiAllowed = aiEnabled && wgate !== 'off';
+      const injectMsg = pickInjectMsg({ pendingResume, consecInjects, aiStep, resumeMsg: resumeMsg(), aiMsg, msg, aiAllowed });
+      // 只有真的敲出 AI 循環裡的一步才推進 aiStep；被 wgate='off' 等閘門擋下、退回一般
+      // "hi" 或 resume 的那些發送不算，避免恢復後循環整段跳號（見上方 aiStep 宣告的說明）。
+      const firedAiStep = !pendingResume && consecInjects >= 2 && aiAllowed && Array.isArray(aiMsg);
+      pendingResume = false;
+      consecInjects++;
+      if (firedAiStep) aiStep++;
       ptyProc.write('\x1b');
       lastFire = now;
-      setTimeout(() => { if (!exiting) { try { ptyProc.write(msg + '\r'); } catch {} } }, escDelayMs);
+      setTimeout(() => { if (!exiting) { try { ptyProc.write(injectMsg + '\r'); } catch {} } }, escDelayMs);
       const idle = idleMs == null ? -1 : Math.round(idleMs / 1000);
-      try { fs.appendFileSync(LOG, `${new Date().toISOString()} inject "${msg}" regime=${regime ?? 'unknown'} idle=${idle}s screenIdle=${Math.round(screenIdleMs / 1000)}s\n`); } catch {}
+      const msgLabel = injectMsg.length > 24 ? `${injectMsg.slice(0, 24)}…` : injectMsg;
+      try { fs.appendFileSync(LOG, `${new Date().toISOString()} inject "${msgLabel}" regime=${regime ?? 'unknown'} idle=${idle}s screenIdle=${Math.round(screenIdleMs / 1000)}s consec=${consecInjects} aiStep=${aiStep} weekly=${wgate}\n`); } catch {}
     }
   }, tickMs);
 

package/src/keepalive.mjs

@@ -24,10 +24,22 @@ export function defaultClaudeDir() {
 
 // Claude Code 把 transcript 存在 ~/.claude/projects/<編碼後的 cwd>/<uuid>.jsonl，
 // 編碼規則為「非英數字元一律換成 '-'」（例：C:\temp\scripts\cwarm → C--temp-scripts-cwarm）。
+// 必須原樣比照 Claude Code 的編碼（不可正規化大小寫），否則對不上它真正建立的資料夾。
 export function encodeProjectDir(cwd) {
   return String(cwd).replace(/[^a-zA-Z0-9]/g, '-');
 }
 
+// cwarm 自家協定檔（AI 狀態、額度橋接）的 cwd 鍵：寫入方（host 的 process.cwd()）與
+// 讀取方（statusline payload 回報的 cwd）可能只有大小寫或斜線方向不同（Windows 常見），
+// 這裡雙方都不必比對 Claude Code 的真實資料夾，故先正規化再編碼，讓這類差異不致兜不起來。
+// 大小寫/斜線方向正規化僅限 Windows：類 Unix 檔案系統多半大小寫敏感，硬轉小寫會把
+// 兩個真正不同的目錄（如 /home/Alice 與 /home/alice）錯誤地映成同一把 key，狀態互相污染。
+export function cwdKey(cwd) {
+  let s = String(cwd).replace(/[\\/]+$/, ''); // 結尾斜線（正／反皆可）先去掉，兩平台通用
+  if (os.platform() === 'win32') s = s.replace(/\//g, '\\').toLowerCase();
+  return encodeProjectDir(s);
+}
+
 // 某資料夾內 mtime 最新的 *.jsonl 完整路徑；沒有則 null。
 function newestJsonlPath(dir) {
   let entries;
@@ -74,9 +86,24 @@ export function transcriptMtimeMs(claudeDir, cwd) {
 // 距上次訊息（transcript 寫入）多久（毫秒）；找不到 transcript 回 null。
 // 這才是 prompt cache 年齡的正確訊號——終端「輸入」（捲動／讀回覆／打到一半沒送出）
 // 都不會刷新 cache，故不以 stdin 計時，改看 transcript mtime。
-export function transcriptIdleMs(claudeDir, cwd, now = Date.now()) {
-  const m = transcriptMtimeMs(claudeDir, cwd);
-  return m == null ? null : now - m;
+// sinceMs（通常給 host 啟動時刻）：mtime 早於它的 transcript 不算數 → 回 null。
+// 語意 = 「Context 0% 不保溫」：本 session 還沒有任何內容時沒有 cache 可保，注入無意義；
+// 也避免把上一個 session 舊檔的 mtime 誤當 idle（曾造成剛啟動就亂敲 "hi"）。
+// 第一句話寫入 transcript（Context > 0%）後，保溫自然啟用。
+// 給了 sinceMs 時**只認 cwd 自己的專案資料夾**、不走跨專案 fallback——否則別的專案
+// 有並行 session 在跑時，其 transcript mtime 晚於啟動時刻、照樣通過 sinceMs 檢查，
+// 等於借別人的活動對自己 0% context 的 session 亂敲。編碼對不上頂多 idle=null 不注入（保守正確）。
+export function transcriptIdleMs(claudeDir, cwd, now = Date.now(), sinceMs = null) {
+  let m;
+  if (sinceMs != null) {
+    const p = newestJsonlPath(path.join(claudeDir, 'projects', encodeProjectDir(cwd)));
+    try { m = p == null ? null : fs.statSync(p).mtimeMs; } catch { m = null; }
+  } else {
+    m = transcriptMtimeMs(claudeDir, cwd);
+  }
+  if (m == null) return null;
+  if (sinceMs != null && m < sinceMs) return null;
+  return now - m;
 }
 
 // 讀 transcript 尾端，判斷這個 session 實際拿到的 cache TTL 檔位。
@@ -153,16 +180,249 @@ function readJsonSafe(p) {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
 }
 
-// IO 版：讀 claudeDir 下的 .credentials.json 與 .claude.json（CLAUDE_CONFIG_DIR 佈局），
+// 讀取憑證/設定來源（billing 與 account 偵測共用，statusline 每次刷新只需讀一遍）：
+// claudeDir 下的 .credentials.json 與 .claude.json（CLAUDE_CONFIG_DIR 佈局），
 // 後者找不到再退回 homedir 的 ~/.claude.json（預設佈局）。macOS 憑證在 Keychain、
 // 沒有 .credentials.json 檔，會自然落到 config 判斷。
-export function detectBillingMode(claudeDir, { env = process.env, homedir = os.homedir() } = {}) {
+export function readAuthSources(claudeDir, { homedir = os.homedir() } = {}) {
   const credentials = readJsonSafe(path.join(claudeDir, '.credentials.json'));
   const config = readJsonSafe(path.join(claudeDir, '.claude.json'))
     ?? readJsonSafe(path.join(homedir, '.claude.json'));
+  return { credentials, config };
+}
+
+export function detectBillingMode(claudeDir, { env = process.env, homedir } = {}) {
+  const { credentials, config } = readAuthSources(claudeDir, { homedir });
   return billingModeFromSources({ env, credentials, config });
 }
 
+// ---- 帳號/訂閱偵測（statusline 顯示用）----
+// 常在兩個帳號間 /login 切換時，光看模型名不知道現在燒的是哪個帳號的額度。
+// email 取自 .claude.json 的 oauthAccount（/login 當下改寫）；訂閱層級取自
+// .credentials.json 的 claudeAiOauth.subscriptionType，rateLimitTier
+//（如 default_claude_max_5x）尾碼可再補上倍率 → "Max 5x"。
+export function accountInfoFromSources({ credentials = null, config = null } = {}) {
+  const email = (config && config.oauthAccount && config.oauthAccount.emailAddress) || null;
+  const oauth = credentials && credentials.claudeAiOauth;
+  let plan = null;
+  const sub = oauth && typeof oauth.subscriptionType === 'string' ? oauth.subscriptionType : '';
+  if (sub) {
+    plan = sub.charAt(0).toUpperCase() + sub.slice(1);
+    const m = /_(\d+x)$/.exec((oauth && oauth.rateLimitTier) || '');
+    if (m) plan += ` ${m[1]}`;
+  }
+  return { email, plan };
+}
+
+// IO 版：與 detectBillingMode 共用 readAuthSources（macOS 憑證在 Keychain 時 plan 會是 null，僅顯示 email）。
+export function detectAccountInfo(claudeDir, { homedir } = {}) {
+  return accountInfoFromSources(readAuthSources(claudeDir, { homedir }));
+}
+
+// ---- 額度視窗（5h window）狀態 ----
+// 資料來源：Claude Code 餵給 statusline 的 payload 有 rate_limits.five_hour 的
+// used_percentage / resets_at（epoch 秒），但 host 收不到 payload，故由 segment.mjs
+// 每次刷新落地成 claudeDir/cwarm-usage.json 橋接檔，host 每 tick 讀取。
+// 狀態語意：
+//   warn    — 用量 ≥ warnPct 且離 reset 還超過 warnGapS（1h）→ 提醒使用者暫時中斷；
+//             不滿 1h 就不提醒，讓尾巴額度照常燒到撞牆（反正 reset 後就作廢）
+//             （保溫照常用 "hi"，不改行為，提醒顯示在 statusline）
+//   limited — 已撞牆（≥ limitPct）→ 注入無意義，暫停等 reset
+//   reset   — 橋接檔裡的 resets_at 已過（撞牆後視窗重置）→ host 下一發改敲 "go on"
+export function usageState({ usedPct, resetsAt, nowSec }, { warnPct = 95, warnGapS = 3600, limitPct = 99 } = {}) {
+  if (usedPct == null || resetsAt == null) return 'unknown';
+  if (nowSec >= resetsAt) return 'reset';
+  if (usedPct >= limitPct) return 'limited';
+  if (usedPct >= warnPct && (resetsAt - nowSec) > warnGapS) return 'warn';
+  return 'normal';
+}
+
+// 以 cwd 編碼進檔名（同 aiStatePath）：不同帳號/專案的並行 session 各寫各的橋接檔，
+// 不會互相覆蓋彼此的額度視窗（曾經全域共用一份，A 帳號會讀到 B 帳號的用量）。
+export function usageBridgePath(claudeDir, cwd) {
+  return path.join(claudeDir, `cwarm-usage-${cwdKey(cwd)}.json`);
+}
+
+// 讀橋接檔；太舊（statusline 停更，如 claude 已關）視同沒有 → null。
+// weekPct / weekResetsAt 為 7 天視窗（rate_limits.seven_day），供週配速管控用。
+export function readUsageBridge(claudeDir, cwd, { maxAgeMs = 600_000, now = Date.now() } = {}) {
+  const o = readJsonSafe(usageBridgePath(claudeDir, cwd));
+  if (!o || typeof o !== 'object' || o.ts == null) return null;
+  if (now - o.ts > maxAgeMs) return null;
+  const sd = o.seven_day && typeof o.seven_day === 'object' ? o.seven_day : {};
+  return {
+    usedPct: o.used_percentage ?? null,
+    resetsAt: o.resets_at ?? null,
+    weekPct: sd.used_percentage ?? null,
+    weekResetsAt: sd.resets_at ?? null,
+  };
+}
+
+// ---- 週配速管控（7 天視窗）----
+// 5h 視窗管當下衝刺，7 天視窗管整週配速：週額度日均只有 100/7 ≈ 14.3%，無人值守
+// 快跑不能只看 5h 有空間。以「按時間比例均攤的進度線」為基準（開窗至今應該用掉
+// elapsed/7d × 100%）分三檔：
+//   ok   — 用量在進度線內 → 快跑無妨
+//   slow — 超線但不到一個日均量 → 退回一個 TTL 一步的慢節奏
+//   off  — 超線一個日均量以上 → 暫停 AI 工作（只剩 "hi" 純保溫），別把週額度燒穿
+// 資料缺失回 'unknown'（交由 5h 檔決策，維持既有行為）。
+export function weeklyGate({ usedPct, resetsAt, nowSec, graceDays = 1 } = {}) {
+  if (usedPct == null || resetsAt == null) return 'unknown';
+  const WEEK = 7 * 86400;
+  const elapsed = Math.min(Math.max(nowSec - (resetsAt - WEEK), 0), WEEK);
+  const expectedPct = (elapsed / WEEK) * 100;
+  const dailyPct = 100 / 7;
+  if (usedPct >= expectedPct + graceDays * dailyPct) return 'off';
+  if (usedPct > expectedPct) return 'slow';
+  return 'ok';
+}
+
+// ---- 無人值守 AI 模式 ----
+// 連續兩次注入之間完全沒有人為鍵盤輸入 → 判定無人值守，第三發起改敲「能與 AI 互動」
+// 的訊息（續推任務/回報進度），而不是傻傻的 "hi"；使用者一敲鍵就歸零回到 "hi"。
+//
+// 人為輸入判斷分兩個世界：
+// - Unix raw mode：純打字（含 Enter）不以 ESC 開頭；終端自動回報（DSR/DA 等 CSI 序列）
+//   都以 ESC 開頭 → 「首位元組不是 ESC」即是人。方向鍵等 ESC 序列被漏算可接受。
+// - Windows：node-pty 對真終端開 win32-input-mode（?9001h），**所有**按鍵都以
+//   ESC[Vk;Sc;Uc;Kd;Cs;Rc_ 封包送達（首位元組必為 ESC）。此時要解封包：
+//   key-down（Kd=1）且帶實際字元（Uc≠0）才算人——這樣終端合成的回報與 key-up 都不誤判。
+const WIN32_INPUT_PACKET_RE = /\x1b\[([0-9;]*)_/g;
+function* win32InputPackets(s) {
+  WIN32_INPUT_PACKET_RE.lastIndex = 0;
+  let m;
+  while ((m = WIN32_INPUT_PACKET_RE.exec(s)) !== null) {
+    const f = m[1].split(';').map((x) => Number(x || 0));
+    yield { vk: f[0] || 0, sc: f[1] || 0, uc: f[2] || 0, kd: f[3] || 0, raw: m[0] };
+  }
+}
+
+// Bracketed paste（\x1b[200~…\x1b[201~）一定是人為貼上——終端自動回報（DSR/DA 等）
+// 不會用這個包法送達，故不論內容為何，含這對標記即視為人為輸入，讓 humanQuiet 正確
+// 為「貼了草稿還沒送出」武裝，不會被開頭的 ESC 誤判成非人。
+const BRACKETED_PASTE_RE = /\x1b\[20[01]~/;
+
+export function looksLikeHumanInput(chunk) {
+  if (!chunk || chunk.length === 0) return false;
+  const s = typeof chunk === 'string' ? chunk : chunk.toString('latin1');
+  if (BRACKETED_PASTE_RE.test(s)) return true;
+  if (s.charCodeAt(0) !== 0x1b) return true;
+  for (const p of win32InputPackets(s)) {
+    if (p.kd === 1 && p.uc !== 0) return true; // win32-input-mode 的實際按鍵
+  }
+  return false;
+}
+
+// AI 模式切換熱鍵。預設 Ctrl+\（0x1C）——Ctrl+] 會被中文輸入法攔成全形】，故棄用；
+// CWARM_TOGGLE_KEY 給單一字元（如 ']'、'\\'、'g'）換成 Ctrl+該鍵，再撞衝突不必改 code。
+// 控制碼算法：字元碼 & 0x1F（']'→0x1D、'\'→0x1C、字母 g→0x07）。無效輸入回預設。
+export function toggleKeySpec(ch) {
+  const c = String(ch ?? '')[0] || '\\';
+  const code = c.charCodeAt(0) & 0x1f;
+  if (code < 1 || code > 31) return toggleKeySpec('\\');
+  return { code, label: `Ctrl+${c.toUpperCase()}` };
+}
+
+// 熱鍵偵測 + 剝除（code = toggleKeySpec().code）。兩種形態，都要求「這個 chunk 恰好
+// 就是熱鍵本身」才觸發，同一標準套用到 Windows：
+// - Unix raw mode：裸控制位元組——**僅當 chunk 恰為單一位元組**才視為熱鍵；
+//   貼上內容夾帶該位元組（log/CSV/條碼 dump）不得誤觸、更不得剝除毀損內容。
+// - win32-input-mode：ConPTY 對真終端永遠開著，大量貼上內容也會被轉成逐字元封包——
+//   若只挑出 Uc=code 的封包來剝除，貼上內容裡剛好含這個字元就會被誤觸且毀損。
+//   故要求**整個 chunk 解出的封包全部都是該熱鍵**（單鍵的 down(+up)，至多 2 個
+//   封包）才算熱鍵；只要混雜其他按鍵封包（含批次貼上），整包原樣放行、不觸發也不剝除。
+// 回傳 { toggled, rest }：rest 為應轉送給 claude 的剩餘位元組。
+export function extractAiToggle(chunk, code = 0x1c) {
+  const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'latin1');
+  if (buf.length === 1 && buf[0] === code) return { toggled: true, rest: Buffer.alloc(0) };
+  const s = buf.toString('latin1');
+  if (!/^(?:\x1b\[[0-9;]*_)+$/.test(s)) return { toggled: false, rest: buf };
+  const packets = [...win32InputPackets(s)];
+  if (packets.length > 0 && packets.every((p) => p.uc === code)) {
+    return { toggled: packets.some((p) => p.kd === 1), rest: Buffer.alloc(0) };
+  }
+  return { toggled: false, rest: buf }; // 混雜其他按鍵/批次貼上 → 一律原樣放行
+}
+
+// humanQuiet 門檻不得吃掉「提早注入」的保命餘裕：short 檔 idleThreshold 240s 就是為了
+// 趕在 300s TTL 前 60s 注入，若 humanQuiet 比它還長，注入會被拖到 cache 冷掉之後。
+// 故上限鉗在 idleThreshold - 60s（不足時歸零，等同不套用）。
+export function clampHumanQuiet(humanQuietMs, idleThresholdS) {
+  return Math.min(humanQuietMs, Math.max(0, idleThresholdS * 1000 - 60_000));
+}
+
+// 這一發該敲什麼：reset 後續跑 > 無人值守 AI 訊息 > 一般 "hi"。
+// aiMsg 可以是字串（固定一句）或陣列（循環工作流：第 3 發起依序輪替，如
+// review → critical review → 保守建議 → 依建議執行 → 回到 review …）。
+// aiAllowed=false（如週配速 'off'）時即使無人值守也只敲一般 "hi"，暫停 AI 工作。
+// aiStep（獨立於 consecInjects 的循環位置計數）：consecInjects 統計「連續注入次數」，
+// 用來判定是否進入無人值守（≥2），但暫停期間送出的普通 "hi" 也會讓它累加——若拿它直接
+// 當循環索引，暫停後恢復會整段跳號、破壞步驟間的依賴（如「依建議執行」承接前一步的發現）。
+// 故循環位置改用呼叫端維護、只在真的敲出 AI 循環訊息時才遞增的 aiStep。
+export function pickInjectMsg({ pendingResume, consecInjects, aiStep = 0, resumeMsg, aiMsg, msg, aiAllowed = true }) {
+  if (pendingResume) return resumeMsg;
+  if (consecInjects >= 2 && aiAllowed) {
+    if (Array.isArray(aiMsg)) return aiMsg[aiStep % aiMsg.length];
+    return aiMsg;
+  }
+  return msg;
+}
+
+// 無人值守 AI 模式的節奏：保溫節奏（一個 TTL 一發）是為省注入次數設計的，但 AI 模式
+// 的目標是推進工作——十分鐘做完一步不該空等五十分鐘。故額度充裕時改用快節奏
+//（paceS，預設 5 分鐘：transcript 靜止 + 冷卻都縮短到 paceS），下列任一條件則退回
+// 原節奏：尚未進入 AI 模式、無橋接資料（保守）、用量 ≥ fastMaxPct、或額度狀態非
+// normal（warn/limited/reset 自有其處理）。快節奏注入間隔遠小於 TTL，cache 恆熱。
+// weekly（weeklyGate 結果）：'slow'/'off' 都不快跑；'unknown' 交由 5h 條件決定。
+// enabled=false（未開 --ai/CWARM_AI，純保溫使用者）時永遠維持原節奏。
+export function aiPacing({ enabled = true, consecInjects, usedPct, ustate, weekly = 'unknown', ttl, idleThreshold, paceS = 300, fastMaxPct = 70 }) {
+  const fast = enabled
+    && consecInjects >= 2
+    && usedPct != null && usedPct < fastMaxPct
+    && ustate === 'normal'
+    && (weekly === 'ok' || weekly === 'unknown');
+  if (!fast) return { ttl, idleThreshold };
+  return { ttl: Math.min(ttl, paceS), idleThreshold: Math.min(idleThreshold, paceS) };
+}
+
+// ---- AI 模式開關狀態檔（host ↔ statusline 溝通用）----
+// host 在啟動、每個 tick、與 Ctrl+] 切換時寫入 {enabled, ts}；statusline 讀取顯示
+// 開關狀態與熱鍵提示。ts 同時是心跳——太舊代表沒有 cwarm host 在跑（或已退出），
+// statusline 就不顯示這一段（避免殘留假狀態）。
+// 以 cwd 編碼進檔名（cwarm-ai-<proj>.json）：多個 cwarm host 並行時各寫各的，
+// statusline 用 payload 的 cwd 對回自己那份，不會 last-writer-wins 互蓋。
+export function aiStatePath(claudeDir, cwd) {
+  return path.join(claudeDir, `cwarm-ai-${cwdKey(cwd)}.json`);
+}
+
+// AI 模式開機初值：--ai 旗標 > CWARM_AI 環境變數（=0/off 可強制關）> 上次持久化狀態
+//（同一個 per-cwd 狀態檔、忽略心跳時效——Ctrl+\ 切過的選擇跨重啟記住）> 預設關。
+export function initialAiEnabled({ flagAi, envAi, persisted } = {}) {
+  if (flagAi === true) return true;
+  if (envAi != null && envAi !== '') return /^(1|on|true|yes)$/i.test(String(envAi));
+  return !!(persisted && persisted.enabled);
+}
+
+export function readAiState(claudeDir, cwd, { maxAgeMs = 60_000, now = Date.now() } = {}) {
+  const o = readJsonSafe(aiStatePath(claudeDir, cwd));
+  if (!o || typeof o !== 'object' || o.ts == null) return null;
+  if (now - o.ts > maxAgeMs) return null;
+  return { enabled: !!o.enabled, key: typeof o.key === 'string' ? o.key : null };
+}
+
+// 讀自訂無人值守指令檔（CWARM_AI_MSG_FILE）：一行一條指令、# 開頭與空行忽略。
+// 內建循環是軟體工程導向的；其他領域（寫作/研究/翻譯…）用這個換掉整套。
+// 檔案不存在或沒有有效行 → null（回退內建循環）。
+export function readAiMsgFile(p) {
+  if (!p) return null;
+  let text;
+  try { text = fs.readFileSync(p, 'utf8'); } catch { return null; }
+  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); // 去掉 UTF-8 BOM（Windows Notepad 常見），
+  // 否則第一行的 '#' 判斷會被隱形的 BOM 字元擋掉，該行不被當註解、悄悄混進指令循環。
+  const lines = text.split(/\r?\n/).map((s) => s.trim()).filter((s) => s && !s.startsWith('#'));
+  return lines.length ? lines : null;
+}
+
 // 純決策：現在該不該注入 keepalive？idleMs = 距上次訊息多久（由 transcriptIdleMs 算）。
 // screenIdleMs = 距 claude 最近一次「畫面輸出」多久；quietMs = 需靜止多久才放行。
 // 為什麼要這個畫面靜默門檻：transcript 在「等你回答必答提示（權限/選單/計畫批准）」與
@@ -170,12 +430,16 @@ export function detectBillingMode(claudeDir, { env = process.env, homedir = os.h
 // 但畫面活動可以：閒置在輸入框時畫面靜止；提示等待時 spinner 在動、生成中持續輸出。
 // 故只有畫面靜止夠久才注入——避免把 hi 的 Enter 送進 modal 誤選預設項，也避免打斷長工具執行。
 // quietMs 省略（null）時不套此門檻（保持純 idle 決策，供既有測試/呼叫者使用）。
-export function decideInject({ now, idleMs, lastFire, idleThreshold, ttl, disabled, screenIdleMs, quietMs }) {
+// humanIdleMs/humanQuietMs：距使用者最後一次敲鍵多久／需靜多久才放行。打字中途停下來
+// 想事情（畫面靜止 >quietMs）不代表人不在——半句草稿 + "hi" + Enter 一起送出就是事故。
+// 故人剛敲過鍵（預設 5 分鐘內）一律不注入；null 不套用（相容既有呼叫者）。
+export function decideInject({ now, idleMs, lastFire, idleThreshold, ttl, disabled, screenIdleMs, quietMs, humanIdleMs, humanQuietMs }) {
   if (disabled) return false;                          // 暫停開關
   if (idleMs == null) return false;                    // 找不到 transcript → 保守不發
   if (idleMs < idleThreshold * 1000) return false;     // 距上次訊息還不夠久
   if (now - lastFire < ttl * 1000) return false;       // 冷卻未滿一個 TTL
   if (quietMs != null && screenIdleMs != null && screenIdleMs < quietMs) return false; // 畫面還在動（提示/生成/打字中）
+  if (humanQuietMs != null && humanIdleMs != null && humanIdleMs < humanQuietMs) return false; // 人剛敲過鍵（可能在打字）
   return true;
 }
 

package/src/statusline/segment.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { defaultClaudeDir, readTtlRegime, regimeParams, detectBillingMode } from '../keepalive.mjs';
+import { defaultClaudeDir, readTtlRegime, regimeParams, billingModeFromSources, accountInfoFromSources, readAuthSources, usageState, usageBridgePath, readAiState } from '../keepalive.mjs';
 
 const claudeDir = defaultClaudeDir();
 const ORIG = path.join(claudeDir, 'cwarm-statusline-orig.json');
@@ -13,10 +13,13 @@ function readStdin() {
   try { return fs.readFileSync(0, 'utf8'); } catch { return ''; }
 }
 
+// 憑證/設定來源整份只讀一次（billing 與帳號段共用），render 路徑不重複 IO。
+const auth = readAuthSources(claudeDir);
+
 // cache 倒數段：用 transcript mtime 當 idle、用 transcript 實測的 cache_creation 判 TTL（1h / 5m）。
 function cacheSegment(payload) {
   // credits/API 計費時 keepalive 已暫停，倒數沒有意義且會誤導 → 顯示暫停標記
-  if (detectBillingMode(claudeDir) === 'credits') return '⏸️ cwarm off (API)';
+  if (billingModeFromSources({ env: process.env, ...auth }) === 'credits') return '⏸️ cwarm off (API)';
   const tp = payload?.transcript_path;
   if (!tp) return '';
   let mtimeMs;
@@ -30,6 +33,58 @@ function cacheSegment(payload) {
   return `♻️ cache ${Math.floor(rem / 60)}m${rem % 60}s`;       // ♻️ 倒數
 }
 
+// 帳號段：兩個帳號間 /login 切換時，顯示現在是哪個帳號、什麼訂閱（如 👤cycompassion·Max 5x）。
+// 每次 statusline 刷新重讀檔案，/login 切完下一次刷新就會反映。
+function accountSegment() {
+  const { email, plan } = accountInfoFromSources(auth);
+  if (!email && !plan) return '';
+  const name = email ? email.split('@')[0] : '?';
+  return plan ? `\u{1F464}${name}·${plan}` : `\u{1F464}${name}`;
+}
+
+// payload 裡可能報 cwd 的幾個欄位，依序嘗試——host 那邊用同一套 cwdKey() 正規化
+// （忽略大小寫/斜線方向），故這裡選到哪個候選字串不影響對得上與否，只要有值即可。
+function payloadCwd(payload) {
+  return payload?.workspace?.project_dir || payload?.cwd || payload?.workspace?.current_dir || null;
+}
+
+// 額度橋接 + 提醒段：host（保溫迴圈）收不到 statusline payload，這裡把 rate_limits.five_hour
+// 落地成 per-cwd 橋接檔給 host 讀（撞牆偵測與 reset 後改敲 "go on" 都靠它）——不同帳號/
+// 專案的並行 session 各寫各的，不會互相覆蓋彼此的額度視窗。
+// 回傳提醒文字：用量 ≥95% 且離 reset 還超過 1 小時 → 建議使用者暫時中斷（接在 cache 倒數之後）；
+// 不滿 1 小時就不提醒，尾巴額度照常燒到撞牆。
+function usageBridgeAndWarn(payload, cwd) {
+  const fh = payload?.rate_limits?.five_hour;
+  if (!fh || typeof fh !== 'object') return '';
+  const usedPct = fh.used_percentage ?? null;
+  const resetsAt = fh.resets_at ?? null;
+  const sd = payload?.rate_limits?.seven_day;
+  if (cwd) {
+    try {
+      fs.writeFileSync(usageBridgePath(claudeDir, cwd), JSON.stringify({
+        used_percentage: usedPct,
+        resets_at: resetsAt,
+        seven_day: { used_percentage: sd?.used_percentage ?? null, resets_at: sd?.resets_at ?? null },
+        ts: Date.now(),
+      }));
+    } catch { /* 落地失敗不影響顯示 */ }
+  }
+  if (usageState({ usedPct, resetsAt, nowSec: Date.now() / 1000 }) !== 'warn') return '';
+  const hLeft = Math.round((resetsAt - Date.now() / 1000) / 3600);
+  return `⚠️ ${Math.round(usedPct)}%、離reset還${hLeft}h，建議暫停`; // ⚠️ NN%、離reset還Nh，建議暫停
+}
+
+// AI 模式開關段：顯示無人值守 AI 模式 on/off 與切換熱鍵。狀態檔以 cwd 編碼命名
+//（多 host 並行各寫各的），用 payload 的專案路徑對回；ts 過舊（>60s，沒有
+// cwarm host 在跑或已退出）就不顯示，避免殘留假狀態。
+function aiSegment(cwd) {
+  if (!cwd) return '';
+  const st = readAiState(claudeDir, cwd);
+  if (!st) return '';
+  const key = st.key || 'Ctrl+\\';
+  return `\u{1F916}AI ${st.enabled ? 'on' : 'off'} (${key})`; // 🤖
+}
+
 // 跑使用者原本存起來的 statusLine 指令（餵同一份 stdin），回傳其輸出；沒有就 null。
 function runOriginal(raw) {
   let orig;
@@ -51,9 +106,15 @@ const raw = readStdin();
 let payload = {};
 try { payload = JSON.parse(raw); } catch { /* 空/壞就用空物件 */ }
 
+const cwd = payloadCwd(payload);
 const seg = cacheSegment(payload);
+const warn = usageBridgeAndWarn(payload, cwd);
 let base = runOriginal(raw);
 if (base == null) base = minimalBase(payload);
-// 接在末行尾（base 末端即最後一行末端）
-const out = seg ? `${base} │ ${seg}` : base;
+// 順序：帳號段 │ base 第一行 │ cache 倒數 │ 🤖AI 開關 │ ⚠️額度提醒；base 其餘行原樣跟在後面。
+// 原 statusline（如 claude-hud）常是多行輸出，所有 cwarm 段一律掛在「第一行」頭尾，
+// 不能傻傻接在字串末端（那會落到最後一行尾）。
+const lines = base.split('\n');
+const first = [accountSegment(), lines[0], seg, aiSegment(cwd), warn].filter(Boolean).join(' │ ');
+const out = [first, ...lines.slice(1)].join('\n');
 process.stdout.write(out + '\n');