<!--
  Portfolio Tracker v15
  v15.0 - 基於 v13，加入持倉保留勾選功能，預設空白持倉
  v15.1 - 配色改為藍黑色系
  v15.2 - Service Worker 自動偵測新版本並更新，不再需要手動清快取
  v15.3 - 雲端報價 CSV 路徑設定欄位，可選擇是否記憶路徑
  v15.4 - GitHub Gist 跨裝置同步（推送/拉取持倉）
  v15.5 - 修正賣出 bug：賣出時不需填價格，確認按鈕文字跟著切換
  v15.6 - 買賣輸入代碼時自動偵測市場與計價幣別（市場欄位改為純分類 tag）
  v15.7 - 新標的一鍵同步至清單，自動觸發基本面更新
  v15.8 - 移除 /yfundamentals 呼叫，基本面統一從 fundamentals.json 讀取
  v15.9 - 左上角顯示版本號
  v15.9.1 - 新增「強制更新PWA」按鈕，清除 SW 快取並重載
  v15.9.2 - 新增「連線診斷」按鈕，測試 fundamentals.json / Proxy / localStorage
  v15.9.3 - 修正 fundamentals.json NaN 問題；調整 Proxy 順序移除 corsproxy.io 優先
  v15.9.4 - 有 fundamentals.json 資料即直接返回，不因技術面 null 去抓 Proxy
  v15.9.5 - 無後端模式下找不到資料顯示「同步中」，不觸發 Proxy 錯誤
  v15.9.6 - 修正 backend_url 導致 _pending 不觸發；修正診斷 NaN 假警報
  v15.001 - 改回 Render 後端架構，恢復 /yfundamentals；server.py 加入 /update-symbols
  v15.002 - 診斷工具加入 Render 連線測試
  v15.003 - update-symbols 改用寫死的 Cloudflare Worker URL，不再依賴 backend_url
  v15.004 - 買入時自動補 .HK 後綴（市場=HK 時）；同步 onSymbolInput 預填後綴
  v15.005 - 修正刪除持倉後重整還原 bug：直接從 localStorage 移除，不依賴 persist 過濾邏輯
  v15.006 - 圓餅圖新增「含現金分布」勾選框；勾選狀態存 localStorage；預設不含現金
  v15.007 - 新增總資產列（庫存＋現金）；新增眼睛隱私按鈕，可隱藏總投入/總市值/總損益/總資產
  v15.008 - 記憶體優化：分頁隱藏時暫停計時器；每小時清除 fundJsonCache；翻譯 cache 限 200 筆
  v15.009 - 新增加密倉位（TWD輸入＋USDT換算）；含加密勾選；總資產列納入加密；隱私模式同步
  v15.010 - 總資產列移出flex容器獨立顯示；移除金額前NT$；加密顏色改為綠色
  v15.011 - 現金/加密 checkbox 對齊；今日損益卡片加盤後提示
  v15.012 - 匯率改為按需更新（1hr TTL快取）；大幅減少 open.er-api 用量
  v15.013 - 新增匯率表彈出視窗（日圓/韓元/新加坡元/歐元/澳幣/泰銖/越南盾）
  v15.014 - Gist 同步加入現金/加密；新增芫荽體字型切換（Aa 按鈕）
  v15.015 - A+/A- 移入頂部按鈕列；移除懸浮字體面板
  v15.016 - 幣別切換移入工具列；按鈕白字；匯入/匯出/更新統一配色
  v15.017 - 持倉明細展開/收合全部；行距縮減；匯率表新增 TWD→各幣反向切換
  v15.018 - 總資產列移至圓餅區頂部；現金/加密/庫存金額改為白色；隱私模式覆蓋現金/加密輸入框及USDT提示
  v15.019 - 全域快取（data/cache.json on GitHub）：基本面2小時TTL跨裝置共享，有後端時自動回寫
  v15.020 - 財報/總經加入全域快取；持倉一覽表頭可點擊排序（代碼A-Z/市值/總損益/損益%）
  v15.021 - 買賣區加入↩上一步/↪下一步/⬆上傳庫存；undo最多50步+redo；持倉明細預設收合
  v15.022 - 效能優化：現金/加密輸入改onchange；saveToStorage防抖500ms；持倉明細差異更新
  v15.023 - 新增 MOXA 股票欄位（含圓餅圖勾選/總資產列/Gist同步）；對齊現金加密輸入欄
  v15.024 - sw.js 改為 no-op：移除所有快取與 fetch 攔截，排除 SW 干擾報價更新
  v15.025 - 報價 CSV 改透過 Cloudflare Worker proxy 抓取，解決桌面瀏覽器 CORS 問題
  v15.026 - 改用 allorigins.win proxy 抓取報價 CSV（Worker 被 Google 401 擋）
  v15.027 - 報價 CSV 改為三個 proxy 依序 fallback（allorigins / codetabs / corsproxy）
  v15.032 - 持倉明細新增「▲ 隱藏 / ▼ 顯示持倉」按鈕，可整體收合隱藏卡片區塊
  v15.032 - 持倉一覽新增隱藏按鈕；持倉明細預設隱藏；Gist 同步新增 sheet_url 欄位，拉取時自動還原並標記 persist=true
  v15.032 - 報價 CSV 比對新增 .TW 後綴彈性匹配，解決台股格式不一致導致更新被忽略的問題
  v15.032 - _fetchSheetCSV 加入 cache: 'no-store'，防止瀏覽器/Proxy 快取舊版 CSV
  v15.032 - 新增「📋 原始報價 CSV」按鈕，一鍵填入預設共享報價連結
  v15.033 - 圓餅圖改為按需渲染：佔比變化 > 0.5% 或每 30 分鐘才重繪，降低不必要的 Chart.js 重建
  v15.034 - UI 文字：MOXA 改為「未上市股票」，含MOXA 改為「含未上市」
  v15.035 - 圓餅圖「其他」門檻從 < 1% 調低為 < 0.5%，如實呈現更多個別持倉
  v15.036 - 持倉一覽表格滑鼠 hover 高亮（淡橘色 #ffcc80），含凍結首欄同步變色
  v15.037 - 持倉一覽點選鎖定高亮：click 鎖定該行，再點同行或點空白解鎖
  v15.038 - 基本面/技術面表頭凍結 + row click 鎖定橘色高亮（與持倉一覽同邏輯）
  v15.039 - 修正基本面/技術面表頭凍結：wrapper 改 overflow-y:auto + max-height:65vh，解決 overflow-x:auto 破壞 sticky 的問題
  v15.040 - manifest orientation 改 any，手機/平板支援自由旋轉；修正總資產列隱私模式 bug（數字未遮蔽）
  v15.041 - 啟動時自動靜默拉取 Gist（有 token 即執行，成功顯示 ☁️ toast，失敗靜默 fallback 本地資料）
  v15.042 - 基本面快取韌性強化：TTL 延長 4→8hr；fundamentals.json 失敗設 null 可重試；重抓失敗保留舊快取不清空
  v15.043 - 拆分更新時間顯示：基本面與技術面各自顯示獨立時間戳記；移除後端 URL 明文顯示
  v15.044 - UI 視覺統一：色調微調（背景/左邊框/glass-card/tab 文字）；全站彩色 emoji 替換為 .ic 單色圖示徽章系統；stat 卡片圖示底色統一
  v15.045 - 新增觀察清單：可追蹤未持有標的，納入基本面/技術面/新聞分析；Gist 同步；預設隱藏
  v15.046 - 已實現損益 Tab：FIFO 批次成本、幣別切換（原幣/TWD）、日期篩選（含過去3/5年）、響應式篩選列（桌機單行/手機兩行）；Gist 拉取強制同步 tradeHistory；CSV 匯出含 Lots＋TradeHistory 區段，匯入自動還原
  v15.047 - 期間報酬率分析：月/季/年切換；已實現報酬率（已實現損益/成本）＋總報酬率（已實現損益/期初市值）；每月自動記錄月度市值快照；Gist 同步快照資料
  v15.048 - 快照改為每日記錄（當日第一次開啟）；期間漲跌幅改為期末-期初/期初（含未實現）；表格欄位改為：期初市值、期末市值、漲跌幅、已實現損益；新快照自動靜默推送 Gist（有 Token 才推，失敗靜默）
  v15.050 - 存款金額可直接編輯（點擊數字修改，onchange 自動儲存）；修正靜默拉取覆蓋本地存款 bug（Gist 無存款時不再清空本地資料）
  v15.050 - Gist 同步穩定化：存款/已實現損益修改後自動推送 Gist（2s debounce）；靜默拉取加入時間戳比較（本地較新則跳過覆蓋）；徹底修復「重新開頁面資料被舊 Gist 蓋掉」問題
  v15.051 - Gist 拉取改用 API 內嵌 content（不再二次 fetch raw_url），徹底消除 GitHub CDN 快取導致拉到舊資料的問題；所有 Gist fetch 加入 cache:'no-store'
  v15.052 - 修正 Yahoo chart API 無資料時誤設 marketOpenedToday=false 導致今日漲跌顯示「-」的 bug
  v15.053 - 台股/港股時區修正：新增 _exchangeTz() 統一依標的市場選時區（.TW→Asia/Taipei, .HK→Asia/Hong_Kong），修正台股收盤後今日漲跌誤移到昨日漲跌的 bug
  v15.054 - Gist 自動推送強化：失敗時指數退避重試（1s→2s→4s→8s→16s，最多 5 次）；網路恢復（online 事件）自動重推；左上角 ⚠ 警示顯示未同步筆數、點擊立即重試；推送成功才清 pending 計數（斷電/關瀏覽器都不會丟資料）
  v15.055 - Gist schema 版本號：payload 加入 schema_version（目前 v1）；拉取時檢查雲端版本，若高於本機（未來 PWA 未更新時）直接拒絕拉取並提示更新，避免破壞性覆蓋；向下相容舊 Gist（無 schema_version 視為 v1）
  v15.056 - Auto-push 遺漏補齊 + UI 清理 + 隱私修正：買入/Undo/Redo/刪除持倉四處缺漏的 _markLocalModified() 補上，現在所有改動都會觸發 2s debounce 自動推送；移除買賣區「⬆ 上傳庫存」與存款頁「⬆ 上傳雲端」兩個冗餘按鈕（auto-push 已覆蓋）；存款頁各銀行金額輸入框與 TWD 換算新增隱私遮罩（原本只有總額有遮）
  v15.057 - 基本面表格新增「下次財報」欄：update_fund.py 抓 yfinance t.calendar 的 Earnings Date 寫入 fundamentals.json（next_earnings_date 欄位）；前端基本面表格首欄之後顯示日期 + 剩餘天數，顏色分級（今日/≤7天紅、≤14天橙、≤30天正常、>30天灰）
  v15.058 - 同步一致性補強：新增 _markAndAutoPush() 統一 helper；持倉明細 inline 編輯（股數/成本價/現價）、單筆/全部保留勾選、CSV 匯入完成後都會標記本地修改並觸發 2s debounce 自動推送 Gist
  v15.059 - stale push 防覆蓋：新增裝置 ID、Gist revision 基準、dirty domains 與 sync_meta（schema 維持 v1 方便回滾）；手動/自動推送前先比對雲端 revision，若本機不是基於最新版則拒絕上傳並保留 pending；庫存/存款顯示本機與雲端時間戳
  v15.060 - 下次財報日期顯示修復 + 槓桿/港股反推原型：前端 fetchSymbolDataFromYahoo() 補上 next_earnings_date / no_earnings / earnings_proxy_symbol 欄位解析與回傳；buildNextEarningsTd 加上「近期無財報」與「財報：原型」小字提示；_CACHE_KEY 從 v7 升至 v8 強制清除舊快取；後端 update_fund.py 新增 EARNINGS_PROXY（AAPX/MSTU/MSFU/NBIL/CCUP/AMDL/AVGX/TSLL/NVDL/GGLL/MUU/PLTU/SNXX/TSMX → 原型；7709/9747 → 海力士/三星）與 NO_EARNINGS_SYMBOLS（00675L/BTC-USD/SLV/SOXX）。嚴格設計約束：mapping 僅作用於 next_earnings_date 欄位，不影響 PE/EPS/技術面/報價/持倉計算（前端 LEVERAGED_MAP 不動）
  v15.061 - 安全與救災可靠性批次：(1) 新增 .github/workflows/check-tokens.yml 每日 UTC 20:00 自動驗證 GIST_TOKEN/GIST_ID 仍有效且 portfolio-tracker-holdings.json 存在，失效時 workflow fail 觸發 GitHub 通知；(2) 新增 data/restore_from_sqlite.py CLI 工具（--list / --latest / --id / --date），從 SQLite 備份還原指定備份的 raw_json 為獨立檔案，不自動覆蓋 Gist；(3) Gist push 401/403 立即停止 retry 並 toast 提示 Token 失效（避免 5 次無意義重試）；(4) MAX_RETRY 達上限後 showWarnToast 提示使用者；(5) 新增 pt_last_push_error localStorage 紀錄最後一次同步錯誤；(6) 手機直向修正：持倉分布圖三勾選（含現金/含加密/含未上市）改用 .pie-input-grid CSS class，540px 以下提示欄與勾選獨立成行避免溢出右邊
  v15.062 - 修補 v15.061 的 auth 判斷漏洞（Codex P1）：GitHub Gist API 401 回傳 "Bad credentials" 而非 "HTTP 401"，原 _isAuthError 只 regex 找 "HTTP \d+" → 抓不到 → Token 失效時仍跑滿 5 次 retry。修法：(1) _fetchGistState / _gistSilentPush / gistPush 三處 throw 都附 e.status = res.status；(2) _isAuthError 優先看 err.status，再 fallback 到 "Bad credentials" / "Requires authentication" / "Must authenticate" 字串比對；(3) _recordPushError 也優先用 err.status；(4) gistPush 的 preflight catch 區塊補上 _recordPushError 與 _handleAuthFailure 呼叫（原本只 setGistStatus 與 showWarnToast，沒記錄、沒停 retry）。Token 失效現在會立即停止重試並提示使用者
  v15.063 - 資料新鮮度 UX + Chart.js SRI + STORAGE_KEYS 集中 + Claude rules：(1) 新增 _freshnessColor() helper；_updateSourceTimes() 與兩處匯率顯示函式依資料年齡套色（基本面 TTL 8hr <6hr 灰藍、6-12hr 橘、>12hr 紅；技術面與匯率 TTL 1hr 同邏輯），看一眼知道資料是否新鮮；(2) Chart.js CDN script tag 加 integrity="sha384-9nhczxUqK87bcKHh20fSQcTGD4qq5GhayNYSYWqwBkINBhOfQLg/P5HG5lF1urn4" + crossorigin="anonymous"，CDN 被入侵時瀏覽器拒絕執行；(3) 新增 STORAGE_KEYS 集中物件登記全部 ~30 個 localStorage key，採保守路線：純新增不動既有 PT_*_KEY 常數，避免破壞既有資料；(4) 新增 .claude/rules/storage-keys.md 與 .claude/rules/cache-strategy.md；更新 .claude/rules/gist-sync.md 補 v15.061/062 auth status 規則。Notion 同步本批不做，等 Codex review 後再補
  v15.064 - 錯誤可觀測性 UI + Region 標記 + Render Health Check：(1) 新增 _recordAppError(source, err, meta) helper；STORAGE_KEYS 加 errorLog ('pt_error_log_v1')，最多 50 筆滾動式錯誤日誌；_recordPushError 連動寫入；(2) 設定 Tab 加錯誤日誌 glass-card：「查看（N 筆）」+「清除」兩按鈕、pre 區塊用 textContent 倒序顯示（避免 innerHTML 注入）；(3) 三類 catch 點埋設：gist_push / gist_pull / csv_proxy_all_fail / fundamentals_json_load / render_health；(4) server.py 新增 GET /health 端點回 JSON {ok:true, service:'portfolio-tracker-backend'}；前端啟動 IIFE 內加 Render warm-up（背景 fetch /health，60s timeout，失敗只寫 log 不彈 toast）；(5) HTML 加 // #region / // #endregion 標記三個關鍵區段（Storage Keys & Freshness Helper / Gist Sync / Analysis Data）方便 VS Code 折疊；(6) Notion 同步本批不做，等 Codex review 後補
  v15.065 - 修補 v15.064 的 P2/P3（Codex review）：(1) P2 startup 相容性：Render warm-up 改用 try/catch + AbortController + setTimeout，避免 iOS Safari < 17.4 / 舊 Chrome 缺 AbortSignal.timeout 時 sync throw 中斷 startAutoRefresh / startAutoAnalysis 等啟動序列；(2) P3 錯誤日誌洗版：_recordAppError 加 60s 內同 source+message 去重，僅更新最後一筆的 ts 與 count，避免 fetchSymbolDataFromYahoo 31 個 symbol 同輪刷新時 fundamentals_json_load 寫 31 筆把 50 筆上限填滿；toggleErrorLog UI 顯示「× N」標示重複次數；(3) 順手把 scripts/pull_log.txt 加進 .gitignore 並 git rm --cached，避免每日排程 log 混進功能批次 commit history
  v15.900 - v15 系列終版凍結（Stable Final）：把 v15.082 的內容鎖死成 v15.9 終版；功能基本穩定（Gist 同步 + system sync channel + userDataHash + master/staging/cancel + FSA + 兩倍漲幅 + capture basis + preflight 誤擋全部修補完成），未來 v15 不再進版，所有開發轉往 v16。本版作為 rollback target — 後續若 v16 改壞，可直接 `git checkout v15.900` 回到此版。git tag: v15.900。
  v15.082 - 修補 v15.081 後 capture basis 語意未跟上 + 收盤後今日損益仍浮動：(P1) 美股收盤後（NY localDate === target）_captureDailyPnlSnapshot 仍用 `isToday ? h.prevClose : h.prevPrevClose` 模糊語意，但 v15.081 已把 baseline 語意改成「prevClose = close[target]」→ isToday=true 時 basis = close[target] ≈ currentPrice → snapshot pnlTWD ≈ 0（看到「美股 +247」而非「+203,482」）；同 marketDate 已有 complete fresh snapshot 時又只看 lastQuoteAt 較新就允許覆蓋 → 一鍵更新刷新 quote meta 後錯誤的 snapshot 蓋掉正確的。修法：capture 改用明確 `close[target] - close[prevTrading]` 公式，來源優先 baseline.marketDate===target → price_cache → stats fallback；basisField 從 'prevClose'/'prevPrevClose' 改 'closePair'；snapshot.holdings[i] 寫入 `prevClose:cTarget, prevPrevClose:cPrev`（明確）；同 target complete snapshot 比對若 pnlTWD 變化 > 5% 印 console.warn（提早發現 basis 語意回歸）。(P2) 今日損益 'closed' 狀態仍計入今日總額且卡片顯示金額 → 收盤後數值持續浮動誤導；`_eligibleTodayStatus` 從 `s === 'open' || s === 'closed'` 收緊為僅 `s === 'open'`；UI mkRow 'closed' 狀態顯示「已收盤，見前次收盤」灰色文字（與 'not_open' / 'closed_or_holiday' 一致風格）。設計約束：不升 PT_SCHEMA_VERSION、不動 STORAGE_KEYS / 同步通道 / user push / pull / master / rollback 流程；snapshot.holdings 欄位語意改變但向下相容（舊 snapshot.holdings[i].prevClose 仍可讀）。
  v15.081 - 修補 v15.080 hotfix 殘洞：(A) loadAnalysis 結尾整包覆蓋 window._prevCloseCache 的 race condition — 即使先前已寫入經 marketDate guard 驗證的 system baseline，也會被 fundamentals.json (f.prev_close) / chart=5d 補抓的舊值整批洗掉，造成「打開時昨日/今日漲跌正確、按完一鍵更新後變兩倍」反覆復發；改為 merge 既有值（不整包賦值）+ 結尾立刻呼叫 _hydratePrevCloseFromBaselines() 讓 system baseline 重新覆蓋（marketDate guard 過的優先於 analysis）。(B) Yahoo chart 三處（fetchSymbolDataFromYahoo 主路徑 / 補抓 / 槓桿 ETF）原本對 closes 做 .filter(v => v != null) 但 timestamps 沒同步 filter → 盤中 close=null 時 tss[last] 仍指向今天但 closes 已少一筆 → opened 誤判 true → prevClose 取 closes[len-2] 變「真.前一交易日」(其實是 prevPrevClose) → 兩倍漲幅 bug；三處統一改 zip + filter 對齊 timestamp 與 close。(C) preflight 新增 cloud_user_same_system_newer state — system sync push 讓 Gist revision 變動但 sync_meta.userDataHash 不變時，B 改 holdings 後 preflight 不再誤判 dirty_cloud_newer_conflict reject；放行條件 cloudHash === lastUserDataHash。(D) hash_match 順手清 dirty / pending（使用者改了又改回原值的情境）；preflight merge 範圍擴大至 baselines + price_cache（不只 snapshots）。(E) _backfillDailyPnlSystemData 寫 baseline 改 prevClose=cTarget / prevPrevClose=cPrev（對齊 runAnalysis 未開盤路徑語意）；snapshot pnl 計算（cTarget - cPrev）不動。(F) _hydratePrevCloseFromBaselines 加 marketDate guard — baseline.marketDate 必須等於該市場 lastCompletedTradingDate 才寫入 _prevCloseCache。(G) silentRefreshPrices / directApplyPrices 後若 _prevCloseCache 缺失，背景排 loadAnalysis 補正；(H) sync-invariants.md §1 補第 4 條 baseline.prevClose 語意；§9 表格加 v15.080 後續修補三條（A merge guard / B chart filter 對齊 / C cloud_user_same_system_newer）；本版同步通道、user push / pull / master / rollback 流程完全不動。
  v15.080 - Daily PnL System Sync Channel + Price Backfill：把昨日損益快照、今日損益基準價、近期收盤價改成獨立 system data 同步通道，不進 user dirty / pending / master flag。動機：v15.079 之前 daily snapshot 雖然存 Gist 但跨裝置無法主動同步（必須等 user 真的改持倉才順帶推），新瀏覽器拉不到「昨日 US 收盤損益」；現在收盤後 capture 完直接走 system push，hash 一致才 PATCH，hash 不同 abort（snapshot 是別份庫存算的不該推）。(1) 規則升級：sync-invariants.md §3 從「snapshot 不可單獨 _gistSilentPush()」升級為「user push vs system push 分流」 — snapshot 不進 user push 但可走 system channel，前提 hash_match + 不彈 toast + 不增 pending；§9 表格加 v15.080 條目。(2) Gist payload additive 新增 system_meta（version/userDataHash/updatedAt/sourceDeviceId/reason）/ daily_pnl_baselines（version/userDataHash/updatedAt/symbols/{sym/{market,prevClose,prevPrevClose,marketDate,fetchedAt,source}}）/ daily_pnl_price_cache（version/updatedAt/symbols/{sym/{market,closes:[{marketDate,close,fetchedAt,source}] 每 sym 最多 10 個交易日}}）；不升 PT_SCHEMA_VERSION（保向下相容）。(3) 儲存層：Gist 唯一持久層 + 純 memory cache（_dailyPnlBaselines / _dailyPnlPriceCache / _systemSyncCooldownTs），不新增 localStorage key、不動 STORAGE_KEYS；離線第一次開啟今日損益顯示「資料讀取中」直到網路恢復。(4) snapshot 完整性：每 market snapshot 加 complete / expectedHoldingsCount / withData / missingSymbols / basisUserDataHash / basisHoldingsHash 欄位，withData === expectedHoldingsCount 才 complete=true；partial 不顯示為昨日損益、不覆蓋 complete；同市場同日已有 complete 時只有同 basis hash 且資料更完整 / quote 更新更晚才覆蓋；basisUserDataHash 是來源標記不是 UI gate（昨日損益一旦完整就作為留存快照顯示）。(5) _captureDailyPnlSnapshot 完整 snapshot 寫入後呼叫 _scheduleSystemSyncPush('daily_pnl_snapshot')，移除 _markAndAutoPush(['dailyPnlSnapshots'])；不增 pending、不顯示「1 筆未同步」。(6) _scheduleSystemSyncPush 開頭 _isApplyingCloudPull guard + debounce 2s；_systemSyncPush fetch 最新 Gist + 比對 userDataHash + hash 不同 abort（_recordAppError('system_sync_hash_mismatch')）+ hash 同則 PATCH 整份 payload 含 system 欄位；失敗只寫 error log，不彈 toast、不增 pending。(7) _mergeDailyPnlSnapshots 候選排序改完整性優先：complete=true > fresh_after_close > basisUserDataHash 同來源 > lastQuoteAt > closedAt。(8) _gistSilentPull / 手動 gistPull 的 hash_match 路徑加 system data merge：仍不覆蓋 user data，但 merge daily_pnl_snapshots / baselines / price_cache + hydrate _prevCloseCache + renderAll；hash 不同時 price cache 仍可放 memory（公開報價）；手動 pull 補 silent pull 後處理（hydrate baselines + renderAll + 1.5s loadAnalysis）。(9) _backfillDailyPnlSystemData(reason)：用 _marketSession 找 lastCompletedTradingDate + 對 active holdings 讀 memory price cache + 不足才 Yahoo chart / yfFetch 補最近 10 個交易日 close + 用市場行事曆找 target 與 previous trading date + 全部 active holdings 都有 close 才補出 complete=true snapshot + 成功 _scheduleSystemSyncPush('daily_pnl_backfill')；失敗不產 complete、不彈 toast、_recordAppError('daily_pnl_backfill') 60s 去重；全域 cooldown 3min + 單 symbol 24hr 已抓過不重抓；觸發點 startup 缺 prevClose / pull 後缺 baseline / system pull 後某市場無 lastCompletedTradingDate snapshot。(10) _validateSystemPayload 仿 v15.077 _validateLocalSyncPayload 嚴格驗證 daily_pnl_baselines.symbols / prevClose 為 number 或 null / market 為 string / closes 為 array 含合法 marketDate + number close；驗證失敗整段 system 區塊忽略，不影響 user data pull、不白畫面、不彈 toast、_recordAppError('system_payload_validate')。設計約束：不升 PT_SCHEMA_VERSION、不動 STORAGE_KEYS、不動 _normalizeHoldingForHash 白名單、不動 user push / pull / master / rollback / FSA 流程；三平台行為一致（system push 不依賴 FSA，但只在 hash_match 才 PATCH 且不增 pending）。
  v15.079 - userDataHash + 三段式手動推送 + 本機回復點：同步判斷核心改用「使用者資料內容 hash」而非 revision/pushedAt，解決「iPhone 推 daily snapshot → cloud revision++ 但核心資料沒變 → Android 顯示『1 筆未同步』反覆要求手動 pull」問題；手動「推送至雲端」改三選一 modal（標記最新版 / 暫存上傳 / 取消）；新增本機回復點讓誤標主版本可還原本機（不影響其他裝置）。(1) sync_meta 新增 4 欄：userDataHashVersion=1、userDataHash（SHA-256 hex）、userConfirmedCloudMaster（{id, at, userDataHash, appVersion, sourceDeviceId} 或 null，只有「標記最新版」push 才寫）。hash 包含 holdings/lots/deposits/tradeHistory/watchlist/currency/sheet_url/cash_pie_cb/crypto_twd/crypto_pie_cb/moxa_twd/moxa_pie_cb；不含 marketSnapshots/daily_pnl_snapshots/pushedAt/sync_meta/Gist revision/報價/FX timestamp/分析 cache/錯誤日誌/app version。舊 Gist 無 hash 時本機即時計算 cloud hash。(2) STORAGE_KEYS 新增 lastUserDataHash / processedMasterIds / rollbackSummary 三鍵；既有 deviceId (pt_device_id) 重用。(3) _classifyCloudSyncStateV2 (async) hash-first：hash 同 → kind='hash_match' 直接更 baseline 不 PATCH；hash 不同 → 走既有 6-state classify。(4) IndexedDB 升 v1→v2，新增 rollbacks store；onversionchange 處理；既有 handles store 不動。(5) 手動 gistPush 進三選一 modal：master → 抓 cloud payload 存 IDB rollback + 寫 master flag + force PATCH；staging → 不寫 master flag 走原 preflight（reject 仍 fallback 到舊 confirm）；cancel → return。(6) silent/manual gistPull 收到未處理 master id：hash 同只更 baseline；hash 異套用 cloud payload；都加 _addProcessedMasterId（避免回復後又被拉回）。(7) recordSnapshot 移除 _gistSilentPush 直接呼叫；snapshot 不再產生 pending count。(8) _applySyncBaseline 加寫 lastUserDataHash。(9) UI 加 #push-mode-modal（覆蓋層 + 3 按鈕）；設定 Tab 加 #rollback-card 啟動偵測 rollbackSummary 顯示「回到標記前雲端」按鈕；rollbackToBeforeMaster(masterId) helper 套用 beforeCloudPayload + 標處理 + 刪 IDB；本機限定，不 PATCH Gist、不影響其他裝置。設計約束：不升 schema_version（additive）；auto-push 永不寫 master flag；silent push 永不強制；hash 計算用 crypto.subtle.digest('SHA-256') + canonical JSON（recursive sort keys）。
  v15.078 - 修補 v15.077 對 Android/iPhone PWA 的影響：(1) `_isFsaSupported()` 真正桌機限定 — 加 mobile UA / `window.isSecureContext` / `indexedDB` 三層擋，原本 Android Chrome 86+ 也支援 `showDirectoryPicker` 會被 v15.077 誤判為支援 FSA，現在 Android / iPhone / iPad / Mobile UA 一律 false → 不走 FSA 任何分支；(2) 移除 init FSA silent pull IIFE 內的「全域 click / keydown capture-phase handler 自動 requestPermission」hack — 這個 hack 本意是「user 第一次互動時自動恢復 FSA 授權」，但在 Android PWA 環境會攔截**所有**第一次點擊（包括切 Tab、按按鈕）→ user 反映「Android 連基本面頁面都沒辦法切換」、「填入 GIST ID 也沒辦法運作」；改為權限過期時只顯示 status 提示「請到設定 Tab → 本地同步 → 點從本地拉取重新授權」，user 主動點按鈕才 prompt（FSA 規範本就如此）；(3) `_hasGistCreds()` 加 input value fallback — 除了讀 localStorage，也檢查 `#gist-token` / `#gist-id` 輸入框值，user 填完還沒按 push 時 FSA 路徑就視為「有 GIST 意圖」自動避讓；(4) `_renderLocalSyncStatus` GIST 已設分支取消整張 `pointer-events:none`，改為三個 sync 按鈕個別 disabled 但「停用本地同步」仍可點 — 讓誤啟用過 FSA 的 user 能直接清除設定；不支援 FSA 分支也把 offBtn disable（沒設過不需要停用）；(5) `_captureDailyPnlSnapshot` 只在 `newStatus === 'fresh_after_close'` 才呼叫 `_markAndAutoPush(['dailyPnlSnapshots'])` — 修「PWA 放著不動仍跳『1 筆改動未同步』」bug；root cause 是 renderAll 每分鐘自動觸發（FX 更新 / CSV silent / analysis 補跑 / 背景回前景 timer 都會 trigger）→ `_maybeCaptureDailyPnlSnapshots` → 市場 status='closed' 但 quote/analysis meta 尚未對齊 target → `pending_quote` 仍寫入並標 dirty domain；現在 pending_quote 中間狀態本機保留但不進 Gist dirty / pending count，等 quote+analysis meta 真正對齊（fresh_after_close）才同步；GIST 使用者 0 影響（原 GIST 函式內容完全不動）
  v15.077 - 本地資料夾同步 FSA 獨立管道（桌機限定，與 Gist 互斥）：給「不申請 GitHub Token、只在桌機用」的使用者另開一條同步管道，搭配 OneDrive / iCloud / Dropbox 等雲端硬碟同步資料夾達到桌機↔桌機自動跨裝置。完全獨立於 Gist：不共用 dirty domain / pending count / classify / preflight，Gist 函式內容 0 行更動。設計：(1) 新增 10 個 STORAGE_KEYS（localSyncEnabled / localSyncFile / localSyncDirName / localSyncBasePushedAt / localSyncLocalModifiedAt / localSyncDirtyDomains / localSyncLastPushAt / localSyncLastPullAt / localSyncLastError / localSyncDeviceId）+ IndexedDB（pt_idb_v1.handles）存 FileSystemDirectoryHandle（unserializable 不能放 localStorage）；新增 _idbPut/_idbGet/_idbDelete helpers 並 catch 無痕模式 / IDB 禁用降級；(2) FSA basic：_isFsaSupported（typeof window.showDirectoryPicker === 'function'）/ _hasGistCreds / _isLocalSyncEnabled（!Gist + 支援 + enabled='1' 三條件）/ _getLocalSyncDeviceId（crypto.randomUUID 第一次啟用生成，跟 Gist pt_device_id 獨立）；permission helpers 分兩條：_localSyncGetDirNoPrompt 啟動只 queryPermission 不 request、_localSyncRequestPermissionOnGesture 手動按鈕才 request 過期權限 — 跟 FSA 規範一致；(3) payload 正式規格：_buildLocalSyncPayload 輸出固定 schema 含 schema_version / app_version / pushedAt / sync_source='local_fsa' / local_sync_meta（payload_version=1, deviceId, basePushedAt, dirtyDomains, fileName）+ 完整資料區段（holdings, watchlist, tradeHistory, deposits, marketSnapshots, daily_pnl_snapshots, currency, exchangeRates, sheet_url, cash_pie_cb, crypto_twd, crypto_pie_cb, moxa_twd, moxa_pie_cb），不存 Gist token / Gist ID；_validateLocalSyncPayload 嚴格驗證 — JSON parse error / schema_version > 本機 / pushedAt 非合法時間 / sync_source 非 local_fsa / 核心欄位（holdings / watchlist / tradeHistory / deposits / marketSnapshots）型別錯誤 / daily_pnl_snapshots 結構不符 → 任一失敗顯示錯誤、不套用、不覆蓋本機；(4) push / pull / disable + dirty domain + auto schedule：_localSyncPush({manual,force}) / _localSyncPull({manual}) 都先 hard guard 檢查 _hasGistCreds() 阻擋同時設兩者；自動 push debounce 2s（_scheduleLocalSyncPush，沒啟用 / Gist 已設都自動 noop）；衝突偵測 — push 前讀檔現存 pushedAt vs 本機 localSyncBasePushedAt，不一致則 silent abort + 寫 lastError + UI 提示，手動 push confirm 後可 force=true 強制覆蓋（silent push 永不強制）；pull 自動偵測「空檔覆蓋有資料本機」防呆（only 手動 pull 不擋）；error 同時寫 localSyncLastError（FSA UI）+ _recordAppError（錯誤日誌複製按鈕）；(5) UI 獨立 glass-card #local-sync-card 不可用 setGistStatus，自己的 #local-sync-status；_renderLocalSyncStatus 依狀態切換 — Gist 已設整塊 opacity:0.4 + pointer-events:none / 不支援 FSA 灰掉「請用桌機 Chrome / Edge」 / 已啟用顯示資料夾名稱 + 上次推/拉時間 + 衝突 / 權限過期「請重新授權」；4 個按鈕：選擇資料夾 / 推送至本地 / 從本地拉取 / 停用本地同步；(6) _markAndAutoPush 尾端加 _markLocalSyncModified + _scheduleLocalSyncPush（既有 Gist auto push 路徑完全不動）；init() 既有 _gistSilentPull 之後加 FSA silent pull IIFE（only queryPermission，過期不 prompt 等手動 gesture）；v15.076 的「沒 Gist 清空 tradeHistory」改為「!Gist && !FSA」，FSA 啟用時保留 tradeHistory；(7) 設計約束 — 不升 Gist schema_version、不改既有 localStorage key 字串、不改 Gist 端任何函式，FSA 不支援平台（iOS Safari / Firefox / Safari macOS / Android PWA）走 CSV 或 Gist
  v15.076 - daily snapshot no-op 去重 + 圓餅圖判斷修正 + UI 批次優化：(P0-1A) `_captureDailyPnlSnapshot` 寫入前用 `_isSnapshotEquivalent` 比對 marketDate / quoteStatus / basisField / source / lastQuoteAt / pnl（容差 0.01）/ holdings 明細；完全等價則 return 不寫 localStorage、不 mark dirty、不 push — pending_quote 不再每次 renderAll 都標 dirty；(P0-1B) `_markLocalModified` 改用 before/after diff dirty domains，只「新增」的 domain 才 +1 pending count — UI「⚠ N 筆未同步」從「呼叫次數」改成「多少類資料尚未同步」，dirty domains 已含 holdings 時再 _markAndAutoPush(['holdings']) 不再 +1；(P0-2) `_shouldRenderPie` 兩個 bug：(a) cashNow 從 `#cash-twd-input` 讀但 renderPie 自己用 `_depositsTWD()`（v15.049 改存款 Tab 後 #cash-twd-input 已非真實來源）→ 改用 `_depositsTWD()` 對齊；(b) `h.valueTWD / grandTotal` 欄位不存在（holdingsWithStats 實際是 `valueTotalTWD`）→ ratio NaN 永遠 return true → 圓餅圖每次 renderAll 都 destroy + new Chart 重建；修法：欄位名修正為 `h.valueTotalTWD`，_pieSnapshot 寫入端同步；(2) 5 張統計卡片桌機 separator + 整體 height 對齊 — 加 `.stat-card-header / .stat-card-amount / .stat-card-subamt / .stat-card-mkblock` CSS class，副金額空時用 `<div style="visibility:hidden">&nbsp;</div>` 撐高，手機 media query 解除 min-height 維持緊湊排版；_byMarketBlock helper 套 .stat-card-mkblock 取代 inline border-top；(3) 隱私模式補強：prevDayCard / dayCard 的 headline / subStr / mkRow 金額全部套 `pv()`，狀態文字（「快照未完整」/「等待收盤快照」/「資料讀取中」/「今日未開盤」/「休市，沿用 MM-DD 快照」/「無持倉」）和 marketDate (MM-DD) 不遮；總損益 % 跟金額一起包進 `pv(fmtPnl(v) + pctStr)` — 避免知道「+12.34%」+ 任一持倉成本反推總投入金額；_kindRow('pnl') 同樣處理；(4) 字體選項擴充為 4 階循環 — 預設 → 芫荽 → Noto Sans TC → 霞鶩文楷 TC → 預設；新增通用 `_ensureFontLink(key)` 取代 `_loadIansuiFont`；`applyFont` 改 async：cssUrl 存在時先 toast「載入字體中…」、await `document.fonts.ready`（5s timeout race）、完成後 toast「已套用：{label}」、逾時 fallback 系統字體不報錯；FONT_ORDER 陣列 + toggleFont 4 階循環；loadFont 對未知 key fallback default；(5) 持倉一覽 row 第一個 td 在國旗左邊加 ↗ 按鈕（28×28 min size，event.stopPropagation 避免冒泡到 row click 鎖定）；新增 `_fillTradeForm(symbol, market)` global helper：填入 #form-symbol / #form-market、呼叫既有 onMarketChange / onSymbolInput、清空 #form-quantity / #form-cost、focus 到 quantity；桌機加 `document.addEventListener('dblclick')` 持倉一覽 row 也填表；不產生 dirty / 不 auto-push（直到使用者按買入）；(順手) 錯誤日誌 glass-card 加「複製」按鈕 + `_copyErrorLog()` helper（navigator.clipboard.writeText JSON）給 codex review / debug 直接貼，省去截圖
  v15.075 - Gist 同步策略改 classify-based + 手動 pull 完整 reset：v15.074 之前只要本機 dirty 就阻擋 silent pull，導致使用者多裝置切換時幾乎永遠走「先推 → preflight reject → 提示手動 pull」死循環，auto-pull 形同無效；改為依 GitHub Gist revision SHA（cloud-truth）4 象限分類本機/雲端狀態（clean_cloud_same / clean_cloud_newer / dirty_cloud_same / dirty_cloud_newer_conflict + no_cloud_base）：本機 clean + 雲端 newer → auto pull；本機 dirty + 雲端 same → auto push；只有真衝突（本機 dirty + 雲端 newer）才停下並提示。新增 _getLocalSyncState / _classifyCloudSyncState / _applySyncBaseline 三個 helper；_preflightGistPush 改 classify 主導並回傳 gistState 物件（caller push 成功後直接拿 cloudRevision 寫 baseline 省一次 fetch）；_gistSilentPull / _gistSilentPush / 手動 gistPull / 手動 gistPush 全部統一走 _applySyncBaseline；啟動序列簡化為無條件 _gistSilentPull()（取代舊「pending>0 先推後拉、push 失敗卡死」分支）；新增 _isApplyingCloudPull flag + _markLocalModified 開頭 guard，避免 pull 套用期間 renderAll / saveDeposits 等內部呼叫意外觸發 dirty 反彈；手動 gistPull 視為「使用者放棄本機未上傳異動」→ 完整 reset（移除既有 saveHistory()；結尾清 history=[] / _redoStack=[] / _syncUndoRedoBtns / PT_LOCAL_MODIFY_TS / clearTimeout(_autoPushTimer/_retryTimer) / _pushRetryCount=0），下次重啟不再被同一批舊 dirty 卡住 auto pull；手動 gistPush 在 preflight reject 時提供「強制覆蓋」逃生口（confirm 對話框，給離線改完回來、雲端已被他裝置動過的場景使用）；silent push 路徑永不強制；順手修 v15.074 漏掉的 P2 — yesterdayPnlTotal.pnlUSD/pnlTWD/hasAny 加總範圍從 _MARKETS 改 _activeMarkets，避免使用者沒持有的市場（如 HK count=0）仍把歷史 snapshot 算進 headline 總額；不升 Gist schema_version、不改既有 localStorage key 字串
  v15.074 - Per-market 昨日損益解耦 + 行事曆精修（v15.073 codex review 修補）：(P1-1) v15.073 把行事曆 + 狀態機接好但仍用三市場 current.marketDate 最舊日當 lastCompleteDate，calculateStats 又以 marketDate ≤ lastCompleteDate gating 選 snapshot；情境 2026-05-01 TW/HK 勞動節休市但 US 正常交易 → TW/HK current=4/30、US current=5/1 → lastCompleteDate=4/30 → US 5/1 fresh 被「5/1 ≤ 4/30」排除反而退回 4/30 previous，違背「各市場停在自己的最後交易日」需求；改寫 yesterdayPnlByMarket 為 per-market 各取自己 latest fresh（從 [current, previous] filter+sort by marketDate），_lastComplete 保留純 UI 診斷不再 gate 選擇；新增 _isFresh(mk, s) helper 同時擋下本機殘留的週末/休市 marketDate 壞資料（_isTradingDay !== false）不依賴 merge 流程；complete 改用 _activeMarkets（依 holdingsByMarket[mk].count）只看實際有持倉的市場 — 沒港股或沒台股的使用者不會永遠卡 incomplete；(P1-2) TW holidays 補 4 天 — 02-12（春節前一日 TWSE 列為市場無交易）/ 09-28（教師節）/ 10-26（光復節補假，10/25 為週日）/ 12-25（行憲紀念日），原本漏掉這些日期會讓 _previousTradingDate 計算錯誤；(P1-3) US earlyClose 移除 2026-07-02 — NYSE 2026 表只列 11/27、12/24 為 early close，7/2 是正常交易日，原設成 13:00 會讓午盤後 session 變 closed 凍進 stale snapshot；(P2) HK 移除 2026-12-28（HKEX 公告無此日，原誤關真實交易日）+ 新增 earlyClose: 02-16/12-24/12-31 半日市（12:00 收市）— HKEX 2026 半日市當天若無 earlyClose 設定，snapshot capture 條件（minutes ≥ closeMin=16:10）要等到 16:10 後才觸發，半日市實際 12:00 後就應視為 closed
  v15.073 - 市場行事曆 + 前交易日損益狀態機（重大模型轉向）：v15.072 用「lastQuoteAt 收盤後 ≥5min」判斷新鮮度，但模型缺市場行事曆，5/1 勞動節 + 5/2-5/3 週末打開時 backfill 會用 lastQuoteAt 的 calendar date 5/1 當 marketDate 凍進 snapshot（5/1 根本沒交易）。重寫架構：(1) 內建 MARKET_CALENDARS（TW 依 TWSE 115 年公告 / HK 依 HKEX 2026 / US 依 NYSE 2026）+ _isTradingDay / _previousTradingDate / _nextTradingDate / _shiftDate helpers；2027 之後年份未涵蓋 → fallback 純週末判斷 + 寫 calendar_unknown 錯誤日誌；(2) _marketSession 取代 _marketClock 由行事曆驅動，回傳 { status, localDate, lastCompletedTradingDate, nextTradingDate, closeMin }（_marketClock 改 alias 不破壞既有 callers）；(3) quote meta pt_market_quote_meta_v1 加 marketDate 欄位（CSV silent / manual apply 寫入時 = lastCompletedTradingDate，不是 calendar 日）；(4) 新增 analysis meta pt_market_analysis_meta_v1：runAnalysis 結尾 _markAnalysisRefresh(['TW','HK','US']) 標 prevClose / prevPrevClose 對齊到的 marketDate；(5) _captureDailyPnlSnapshot 完全重寫 — target = session.lastCompletedTradingDate；status='open' 不 capture；fresh_after_close 必要條件 = quote meta + analysis meta 兩個 marketDate 都 === target；backfill 必須完全對齊（避免錯快照擴散到 Gist）；isToday 用 prevClose 算 pnl，backfill 用 prevPrevClose 算（A1：自己 loop holdingsWithStats 重算，不讀 stats.todayPnlByMarket）；double-check _isTradingDay(marketKey, target)===true 才寫入（A2：snapshot.marketDate 永遠是真交易日）；(6) _mergeDailyPnlSnapshots 候選過濾：丟棄 _isTradingDay 明確回 false 的 marketDate（清理 v15.071/072 殘留週末資料）；(7) UI 微調：昨日損益卡片標題下方加「前交易日快照」副標、mkRow 顯示 (MM-DD)、今日損益休市顯示「休市，沿用 MM-DD 快照」；(8) calculateStats 在 todayPnlByMarket[mk] 加 lastCompletedTradingDate 給 UI 用；(9) _isQuoteFreshAfterClose / _lastQuoteLocalInfo 標 deprecated 但保留（避免外部呼叫失敗），新流程不再使用「lastQuoteAt minutes ≥ closeMin + 5」這條規則
  v15.072 - 修補 v15.071 五個快照新鮮度落差（Codex review P1×2 + P2×3）：(P1-A) runAnalysis 結尾原本呼叫 _markBatchQuoteRefresh(['TW','HK','US'], 'yahoo-runAnalysis')，但這條路徑只更新 prevClose / prevPrevClose / marketOpenedToday cache，並沒有寫 holdings.currentPrice → 收盤後 capture 會把 stale 現價凍進 fresh_after_close snapshot 並推上 Gist；移除這個呼叫，留 silent / manual CSV 才 mark；(P1-B) silentRefreshPrices / directApplyPrices 原本只看 updated > 0 就無條件標 TW+HK+US 三市場，CSV 沒覆蓋的市場仍會被判 fresh；改為用 _holdingMarketKey 累計 updatedMarkets Set，只 mark 實際刷到報價的市場；(P2-A) 昨日損益 headline 改用 yesterdayPnlTotal.complete（lastCompleteDate gating 過的旗標）才顯示總額，部分市場 hasAny 顯示「快照未完整」灰字；之前用 hasAny 會把 US-only 合計誤讀為「昨日損益」總額，又踩回時間軸混搭問題；(P2-B) _loadDailyPnlSnapshots 的 v1→v2 migration 直接 return v2 沒呼叫 _computeLastCompleteDate 也沒寫回 localStorage → 升級使用者明明有三市場 v1 快照，昨日損益卻顯示「等待收盤快照」直到下次 capture / pull；補 _computeLastCompleteDate + _saveDailyPnlSnapshots 立即持久化；(P2-C) _captureDailyPnlSnapshot 只在 status='closed' 工作，市場當地午夜後狀態變 not_open / closed_or_holiday → 昨天收盤後到午夜沒開過 App、或週末才開，永遠不會補昨天那筆 snapshot；新增 _lastQuoteLocalInfo helper + _captureDailyPnlSnapshot 加 backfill 分支：not_open / closed_or_holiday 時若 lastQuoteAt 在「該市場時區屬於上一交易日的收盤後 ≥ 5 分鐘」就用 lastQuoteAt 的 calendar date 為 marketDate 補建 fresh_after_close snapshot（source='backfill'）；不查歷史交易日表，純信任 lastQuoteAt 來源
  v15.071 - Daily PnL Snapshot 跨裝置同步 + 收盤後新鮮度防呆：(1) Gist payload 加 daily_pnl_snapshots 欄位（schema_version 不升），_gistSilentPush / gistPush 都帶；_gistSilentPull / gistPull 收到後呼叫 _mergeDailyPnlSnapshots merge（不直接覆蓋）；preflight 時順手 merge 雲端 snapshot 進本機，避免 push 洗掉雲端較新值；(2) 新增 _mergeDailyPnlSnapshots(local, remote) 三層優先序 merge：fresh_after_close > lastQuoteAt 較晚 > closedAt 較晚；每市場取最新 marketDate 為 current、次新為 previous，重算 lastCompleteDate；(3) 新增 pt_market_quote_meta_v1 storage 記錄各市場批次報價最後時間 + 來源；新增 _markBatchQuoteRefresh helper；refreshAllData / silentRefreshPrices / runAnalysis 三個批次報價路徑都呼叫；單一手動改價（持倉 inline 編輯）不更新 lastQuoteAt 避免凍進快照；(4) snapshot 結構加 quoteStatus / lastQuoteAt 欄位；_captureDailyPnlSnapshot 加 _isQuoteFreshAfterClose 檢查（lastQuoteAt 必須 ≥ 收盤時間 + 5 分鐘才標 fresh_after_close，否則 pending_quote）；同日 pending 可被 fresh 覆蓋、fresh 只能被 lastQuoteAt 更晚的 fresh 覆蓋；_computeLastCompleteDate 只計 fresh 的 marketDate；(5) _captureDailyPnlSnapshot 寫入後 _markAndAutoPush(['dailyPnlSnapshots']) 立刻同步雲端；_buildSyncMeta domain list 加 dailyPnlSnapshots
  v15.070 - 三張卡片市場分項 + Codex P1/P2/P3 修正：(A) 總投入 / 總市值 / 總損益三張卡片新增台股 / 美股 / 港股分項，calculateStats 加 holdingsByMarket 累計，renderStats 新增 _kindRow + _byMarketBlock helper；(P1) 昨日損益必須是「同一完整 portfolio day」：snapshot schema 升級 v1→v2，markets[mk] 改為 { current, previous } 結構，新增 lastCompleteDate（取三市場 current.marketDate 的最舊日期）；yesterdayPnlByMarket 改為依 lastCompleteDate gating 選擇 snapshot，避免 TW=今天 / US=昨天 / HK=不確定的混搭日期；_loadDailyPnlSnapshots 加 v1→v2 migration（既有資料無痛升級）；(P2) todayPnlTotal 排除 not_open / closed_or_holiday：台北早上 10 點時美股盤前不再算進今日總損益；(P3) 今日損益市場列：not_open / closed_or_holiday 顯示「今日未開盤 / 休市」純文字、不顯示金額，避免「美股 今日未開盤 +$xxx」自相矛盾畫面
  v15.069 - 市場時間軸 + 今日/昨日損益穩定化：(1) 新增 _holdingMarketKey / _marketClock helper（TW/HK/US 三市場時段判斷）；(2) calculateStats 擴展 todayPnlByMarket / yesterdayPnlByMarket / todayPnlTotal / yesterdayPnlTotal；今日損益按市場 status 拆分顯示（盤中/已收盤/今日未開盤/假日）；昨日損益改讀 pt_daily_pnl_snapshots_v1 凍結快照（不再用即時計算成浮動數字）；(3) 收盤快照流程：每市場 status='closed' 且當天無快照時自動 capture（_maybeCaptureDailyPnlSnapshots 在 renderAll 後觸發）；(4) UI：今日/昨日卡片永遠顯示，內加三行台股/美股/港股分項；卡片再也不會因「沒開盤」整個消失（修 v15.052 副作用）；(5) STORAGE_KEYS 加 dailyPnlSnapshots（不寫 Gist，純本機）；(6) 啟動 hydrate 抽成 _hydrateDailyPnlCachesFromAnalysisCache；Gist silent pull 成功後也呼叫並排程 loadAnalysis 讓新裝置不用等 1hr 才有資料；(7) 不改 Gist payload schema、不 rename 既有 localStorage key
  v15.068 - 修補 v15.066 P3：版本檢查 remote==='v15.066' 對 current==='v15.068' 也會誤判為新版彈 toast；GitHub Pages CDN 邊緣節點傳播延遲時可能拿到舊版 HTML → 誤觸提示 → 點下去 reload 又拿舊版（甚至倒退）。修法：新增 _parseAppVersion / _isNewerVersion 解析 [major, minor]，只在 remote 嚴格大於 current 時彈 toast；remote 較舊或相同時靜默繼續輪詢
  v15.067 - 修補 v15.066 持倉表 diff 排序 bug（Codex review）+ 加碼欄位排序：(1) bug 修正：_patchHoldingTableBody 原本只在 fp-same 分支做位置校正，當 fp 改變（內容變動）走 replaceWith 分支時，新 row 留在舊位置不會移到新 index，導致排序錯亂。修法：每輪 forEach 結束都統一做位置校正（不論新建 / replace / move），對齊既有 renderHoldingsDetail 模式。(2) 加碼：昨日漲跌 / 今日漲跌 / 今日損益 三欄改為可點擊排序，新增 sort key prevDayPct / dayPct / dayPnl；今日損益依目前幣別排序；null 值（沒有該欄資料的 row）一律排到最後不論 asc/desc。
  v15.066 - 持倉一覽差異更新 + PWA 版本更新提示（Codex review 修正版）：(1) renderTable(stats) 重構：新增 _holdingRowCache / _holdingRowFingerprint / _buildHoldingRowHTML / _patchHoldingTableBody 四個 helper；不再對 holdings-table 整體 innerHTML，改 thead/tfoot 個別重建 + tbody DOM diff；fingerprint 含 i 解決奇偶背景問題；每輪自動校正 row 位置（排序變動 / 自動報價更新都對應）。每分鐘自動更新時滾動位置不再跳回頂端、click 鎖定 / hover 狀態保留、低規格手機 CPU 下降。(2) PWA 版本更新提示：新增 const APP_VERSION = 'v15.066'；_checkAppVersion 用 regex 對網路 HTML 抓版本字串比對 APP_VERSION（不依賴第一次 baseline，「打開就是舊版」情境也能提示）；啟動 5 分鐘後第一次檢查，之後每 30 分鐘；找到新版彈藍色 toast「⚡ 發現新版本，點此重新載入」+ id guard 不重複；navigator.onLine === false 跳過 + document.visibilityState === 'hidden' 跳過；錯誤 6hr 同 source 上限避免離線洗版日誌
-->
<!DOCTYPE html>
<html lang="zh-TW">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
    <title>Portfolio Tracker v15 持倉追蹤</title>

    <!-- PWA / Add to Home Screen -->
    <link rel="manifest" href="manifest.json">
    <meta name="theme-color" content="#2563eb">
    <meta name="mobile-web-app-capable" content="yes">
    <!-- iOS Safari -->
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <meta name="apple-mobile-web-app-title" content="持倉追蹤">
    <link rel="apple-touch-icon" href="icon-192.png">

    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js"
            integrity="sha384-9nhczxUqK87bcKHh20fSQcTGD4qq5GhayNYSYWqwBkINBhOfQLg/P5HG5lF1urn4"
            crossorigin="anonymous"></script>
    <script>
      // 註冊 Service Worker + 自動偵測新版本並更新
      if ('serviceWorker' in navigator) {
        window.addEventListener('load', async () => {
          try {
            const reg = await navigator.serviceWorker.register('./sw.js');

            // 偵測到新版 SW → 自動跳過等待，立即接管
            reg.addEventListener('updatefound', () => {
              const newSW = reg.installing;
              if (!newSW) return;
              newSW.addEventListener('statechange', () => {
                if (newSW.state === 'installed' && navigator.serviceWorker.controller) {
                  // 有新版本，通知舊 SW 讓位
                  newSW.postMessage({ type: 'SKIP_WAITING' });
                }
              });
            });

            // 新 SW 接管後自動重新載入頁面
            navigator.serviceWorker.addEventListener('controllerchange', () => {
              window.location.reload();
            });

            // 每次開啟 app 主動檢查有無更新
            reg.update();

          } catch(e) { /* 離線時靜默失敗 */ }
        });
      }
    </script>
    <style>
        /* 使用微軟正黑體，跨平台 fallback 順序：Windows → macOS → Android/Web */
        * { box-sizing: border-box; }
        html { scroll-behavior: smooth; }
        body { 
            margin: 0; 
            overflow-x: hidden; 
            overflow-y: auto; 
            font-family: 'Microsoft JhengHei', '微軟正黑體', 'PingFang TC', 'Heiti TC', sans-serif;
            min-height: 100vh;
            background: linear-gradient(135deg, #060d1a 0%, #081b30 60%, #071224 100%);
            padding: 2rem;
            position: relative;
            color: #e2e8f0;
        }
        
        .glass-card { background: linear-gradient(135deg, rgba(11,26,51,0.97) 0%, rgba(6,13,26,0.99) 100%); backdrop-filter: blur(20px); border: 1.5px solid rgba(56,139,253,0.18); border-radius: 20px; box-shadow: 0 8px 32px rgba(0,0,0,0.6), inset 0 1px 0 rgba(96,165,250,0.08); position: relative; overflow: hidden; }
        
        .stat-card { background: linear-gradient(135deg, rgba(56,139,253,0.15) 0%, rgba(37,99,235,0.1) 100%); border: 2px solid rgba(56,139,253,0.4); border-radius: 16px; padding: 1.5rem; transition: border-color 0.3s, box-shadow 0.3s; position: relative; overflow: hidden; box-shadow: 0 4px 20px rgba(56,139,253,0.2), inset 0 1px 0 rgba(255,255,255,0.1); container-type: inline-size; display:flex; flex-direction:column; }
        /* v15.076：5 張卡片內部區塊節奏統一，桌機 separator 對齊 */
        .stat-card-header { min-height: 56px; }
        .stat-card-amount { min-height: 36px; }
        .stat-card-subamt { min-height: 22px; }
        .stat-card-mkblock { margin-top: auto; padding-top: 0.4rem; border-top: 1px solid rgba(255,255,255,0.06); }
        @media (max-width: 540px) {
            .stat-card-header, .stat-card-amount, .stat-card-subamt { min-height: auto; }
        }
        /* 主金額：container-type 量 content box；padding≈48px 需較高 cqw 補回 */
        .stat-amount { font-size: clamp(1.15rem, 12cqw, 2rem) !important; font-weight: 700; white-space: nowrap; line-height: 1.25; }
        .stat-amount-sub { font-size: clamp(0.88rem, 5cqw, 1.05rem) !important; white-space: nowrap; }
        /* 損益主行：flex 讓百分比貼右 */
        .stat-pnl-row { display:flex; align-items:baseline; justify-content:space-between; gap:0.4rem; flex-wrap:nowrap; }
        .stat-pct { font-size: clamp(0.78rem, 4.5cqw, 1rem) !important; font-weight:600; white-space:nowrap; flex-shrink:0; }
        .stat-card::before { content: ''; position: absolute; top: -50%; right: -50%; width: 200%; height: 200%; background: radial-gradient(circle, rgba(56,139,253,0.12) 0%, transparent 70%); pointer-events: none; }
        
        .holding-row { background: linear-gradient(135deg, rgba(15,30,60,0.6) 0%, rgba(10,20,40,0.8) 100%); border: 2px solid rgba(59,130,246,0.3); border-left: 4px solid #3b82f6; border-radius: 16px; padding: 0; margin-bottom: 2px; transition: border-color 0.3s; animation: slideIn 0.5s ease; position: relative; overflow: hidden; }
        .holding-header { display:flex; justify-content:space-between; align-items:center; padding:0.65rem 1rem 0.65rem 1.25rem; cursor:pointer; gap:0.5rem; flex-wrap:wrap; user-select:none; }
        .holding-header:hover { background:rgba(59,130,246,0.05); }
        .holding-body { padding:0.25rem 1rem 0.85rem 1.25rem; border-top:1px solid rgba(255,255,255,0.06); }
        .holding-row::before { content: ''; position: absolute; top: 0; left: 0; width: 4px; height: 100%; background: linear-gradient(180deg, #60a5fa 0%, #2563eb 100%); box-shadow: 0 0 20px rgba(59,130,246,0.5); }
        body.privacy-active .pv-field { color: transparent !important; text-shadow: 0 0 7px rgba(200,200,200,0.4) !important; }
        body.privacy-active .pv-hint  { visibility: hidden; }
        
        @keyframes slideIn { from { opacity: 0; transform: translateX(-20px); } to { opacity: 1; transform: translateX(0); } }
        
        input, select { width: 100%; padding: 0.75rem 1rem; background: rgba(6,13,26,0.85); border: 1.5px solid rgba(56,139,253,0.22); border-radius: 10px; color: #93c5fd; font-size: 0.95rem; transition: all 0.3s ease; font-family: 'Microsoft JhengHei', '微軟正黑體', 'PingFang TC', 'Heiti TC', sans-serif; font-weight: 500; }
        input:focus, select:focus { outline: none; border-color: #3b82f6; box-shadow: 0 0 20px rgba(59,130,246,0.2), inset 0 1px 0 rgba(255,255,255,0.05); background: rgba(6,13,26,0.95); }
        
        button { padding: 0.75rem 1.5rem; border: none; border-radius: 10px; font-weight: 600; cursor: pointer; transition: opacity 0.2s, box-shadow 0.2s; font-family: 'Microsoft JhengHei', '微軟正黑體', 'PingFang TC', 'Heiti TC', sans-serif; text-transform: uppercase; letter-spacing: 1px; position: relative; overflow: hidden; }
        button::before { content: none; }
        
        .btn-primary { background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%); color: #fff; box-shadow: 0 4px 15px rgba(37,99,235,0.4); }
        .btn-delete { background: rgba(239,68,68,0.2); color: #ef4444; padding: 0.5rem; border-radius: 8px; border: 2px solid rgba(239,68,68,0.4); }
        
        .profit { color: #10b981; text-shadow: 0 0 10px rgba(16,185,129,0.5); }
        .loss { color: #ef4444; text-shadow: 0 0 10px rgba(239,68,68,0.5); }
        .mono { font-family: 'Microsoft JhengHei', '微軟正黑體', 'PingFang TC', 'Heiti TC', sans-serif; font-weight: 600; }
        
        .market-badge { display: inline-flex; align-items: center; gap: 0.5rem; padding: 0.25rem 0.75rem; background: linear-gradient(135deg, rgba(30,58,110,0.35) 0%, rgba(20,40,80,0.3) 100%); border: 1.5px solid rgba(56,139,253,0.3); border-radius: 8px; font-size: 0.85rem; font-weight: 700; }
        
        @keyframes float { 0%, 100% { transform: translateY(0px) rotate(0deg); } 50% { transform: translateY(-20px) rotate(10deg); } }
        @keyframes shimmer { 0% { background-position: -1000px 0; } 100% { background-position: 1000px 0; } }
        @keyframes spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
        
        #pieCanvas { max-width: 100%; height: 400px; }
        .csv-file-input-hidden { position:fixed !important; top:-9999px !important; left:-9999px !important; width:1px !important; height:1px !important; opacity:0 !important; overflow:hidden !important; padding:0 !important; border:none !important; }
        /* ── Tab System ── */
        .tab-btn { background:rgba(8,16,32,0.7); color:#7e93a6; border:1.5px solid rgba(56,139,253,0.12); border-radius:12px 12px 0 0; padding:0.65rem 2rem; font-size:1rem; font-weight:700; cursor:pointer; transition:all 0.25s; letter-spacing:1px; text-transform:none; }
        .tab-btn.active { background:linear-gradient(135deg,rgba(30,58,110,0.45) 0%,rgba(18,38,80,0.35) 100%); color:#93c5fd; border-color:rgba(56,139,253,0.4); border-bottom-color:transparent; }
        .tab-pane { display:none; }
        .tab-pane.active { display:block; }
        /* indicator badges */
        .kd-up   { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(16,185,129,0.2); color:#10b981; font-weight:700; font-size:0.8rem; }
        .kd-down { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(239,68,68,0.15); color:#ef4444; font-weight:700; font-size:0.8rem; }
        .kd-neu  { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(100,116,139,0.2); color:#a8bdd0; font-weight:700; font-size:0.8rem; }
        .rsi-ob  { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(239,68,68,0.2); color:#ef4444; font-weight:700; font-size:0.8rem; }
        .rsi-os  { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(59,130,246,0.2); color:#60a5fa; font-weight:700; font-size:0.8rem; }
        .rsi-neu { display:inline-block; padding:0.15rem 0.5rem; border-radius:5px; background:rgba(100,116,139,0.2); color:#a8bdd0; font-weight:700; font-size:0.8rem; }
        /* ── Unified Icon Badge ── */
        .ic { display:inline-flex; align-items:center; justify-content:center; width:1.25em; height:1.25em; border-radius:4px; font-size:0.82em; font-style:normal; font-weight:700; vertical-align:-0.12em; line-height:1; background:rgba(96,165,250,0.08); border:1px solid rgba(96,165,250,0.1); color:inherit; }

        /* ── 凍結欄（持倉代碼）── */
        #tab-pane-2 table thead th:nth-child(1),
        #tab-pane-2 table tbody td:nth-child(1),
        #tab-pane-3 table thead th:nth-child(1),
        #tab-pane-3 table tbody td:nth-child(1),
        #holdings-table thead th:nth-child(1),
        #holdings-table tbody td:nth-child(1),
        #holdings-table tfoot td:nth-child(1) {
            position: sticky;
            left: 0;
            z-index: 3;
            background: #070f20;
            box-shadow: 3px 0 8px rgba(0,0,0,0.6);
        }
        /* 表頭凍結欄需更高 z-index */
        #tab-pane-2 table thead th:nth-child(1),
        #tab-pane-3 table thead th:nth-child(1),
        #holdings-table thead th:nth-child(1) { z-index: 5; }
        /* 持倉一覽凍結欄寬度 */
        #holdings-table thead th:nth-child(1),
        #holdings-table tbody td:nth-child(1),
        #holdings-table tfoot td:nth-child(1) { min-width:110px; max-width:110px; width:110px; }
        /* 持倉一覽 hover highlight */
        #holdings-table tbody tr { transition: background 0.15s; }
        #holdings-table tbody tr:hover { background: rgba(255,204,128,0.18) !important; }
        #holdings-table tbody tr:hover td:nth-child(1) { background: rgba(255,204,128,0.18) !important; }
        #holdings-table tbody tr.hrow-selected { background: rgba(255,204,128,0.35) !important; }
        #holdings-table tbody tr.hrow-selected td:nth-child(1) { background: rgba(255,204,128,0.35) !important; }
        /* 基本面 & 技術面 & 持倉一覽表頭凍結 */
        #tab-pane-2 table thead th,
        #tab-pane-3 table thead th,
        #holdings-table thead th { position: sticky; top: 0; z-index: 4; background: rgba(8,16,40,0.97); }
        /* 基本面 & 技術面 click 鎖定高亮 */
        #tab-pane-2 table tbody tr { transition: background 0.15s; }
        #tab-pane-3 table tbody tr { transition: background 0.15s; }
        #tab-pane-2 table tbody tr:hover,
        #tab-pane-3 table tbody tr:hover { background: rgba(255,204,128,0.12) !important; }
        #tab-pane-2 table tbody tr:hover td:nth-child(1),
        #tab-pane-3 table tbody tr:hover td:nth-child(1) { background: rgba(255,204,128,0.12) !important; }
        #tab-pane-2 table tbody tr.hrow-selected { background: rgba(255,204,128,0.35) !important; }
        #tab-pane-2 table tbody tr.hrow-selected td:nth-child(1) { background: rgba(255,204,128,0.35) !important; }
        #tab-pane-3 table tbody tr.hrow-selected { background: rgba(255,204,128,0.12) !important; }
        #tab-pane-3 table tbody tr.hrow-selected td:nth-child(1) { background: rgba(255,204,128,0.12) !important; }
        /* 新聞 & 總經 Tab 樣式 */
        .news-item:hover { border-color: rgba(56,139,253,0.5) !important; background: linear-gradient(135deg,rgba(20,40,70,0.8) 0%,rgba(15,30,55,0.9) 100%) !important; }
        .macro-card { background:rgba(15,30,60,0.5); border:1px solid rgba(59,130,246,0.2); border-radius:10px; padding:0.75rem; transition: all 0.2s; }
        .macro-card:hover { border-color: rgba(59,130,246,0.4); }

/* ═══════════════════════════════════════
           行動版響應式樣式 (≤640px)
           ═══════════════════════════════════════ */
        @media (max-width: 640px) {

            /* 全體邊距最小化 */
            body { padding: 0.25rem !important; }

            /* 標題區 */
            #main-header { padding-top: 2.6rem !important; margin-bottom: 0.5rem !important; }
            #main-header-wrap { padding: 0.5rem 0.75rem !important; margin-bottom: 0.2rem !important; }
            #main-title { font-size: 1.35rem !important; letter-spacing: 0.5px !important; }
            #main-header .subtitle { font-size: 0.68rem !important; letter-spacing: 0.3px !important; }


            /* Tab 標籤縮小 */
            .tab-btn { padding: 0.5rem 0.65rem !important; font-size: 0.78rem !important; letter-spacing: 0 !important; }

            /* 統計卡片：2欄、極小間距 */
            #stats-grid { grid-template-columns: 1fr 1fr !important; gap: 0.4rem !important; margin-bottom: 0.6rem !important; }
            .stat-card { padding: 0.65rem 0.6rem !important; border-radius: 10px !important; }

            /* ★ 所有 glass-card 縮小左右 padding ★ */
            .glass-card { padding: 0.65rem !important; border-radius: 12px !important; margin-bottom: 0.6rem !important; }
            /* glass-card 內部若有額外包層也一起縮 */
            .glass-card > div { padding-left: 0 !important; padding-right: 0 !important; }

            /* 持倉明細 */
            .holding-row { padding: 0 !important; border-radius: 10px !important; margin-bottom: 2px !important; }
            .holding-header { padding: 0.55rem 0.75rem 0.55rem 1rem !important; }
            .holding-body { padding: 0.25rem 0.75rem 0.65rem 1rem !important; }
            .holding-row input[type="number"] { width: 100% !important; }

            /* 分析控制列 */
            #analysis-ctrl { padding: 0.4rem 0 0 0 !important; }
            #analysis-ctrl > div { gap: 0.35rem !important; flex-wrap: wrap !important; }
            #analysis-btn { padding: 0.5rem 0.85rem !important; font-size: 0.8rem !important; }
            #backend-btn  { padding: 0.5rem 0.65rem !important; font-size: 0.74rem !important; }
            #fund-source-time, #tech-source-time { font-size: 0.68rem !important; }

            /* 基本面/技術面/新聞/總經 tab padding */
            #tab-pane-2,
            #tab-pane-3,
            #tab-pane-4,
            #tab-pane-5,
            #tab-pane-6,
            #tab-pane-7 { padding-top: 0.4rem !important; }

            /* 表格字體縮小 */
            #fund-tbody td, #tech-tbody td { font-size: 0.74rem !important; padding: 0.35rem 0.35rem !important; }

            /* Modal */
            #import-modal > div,
            #confirm-modal > div,
            #review-modal > div { padding: 0.9rem !important; border-radius: 12px !important; }

            /* 表單欄位：2欄 */
            #trade-form-grid { grid-template-columns: 1fr 1fr !important; gap: 0.5rem !important; }
        }

        /* 超小螢幕 (≤380px) */
        @media (max-width: 380px) {
            body { padding: 0.15rem !important; }
            .tab-btn { padding: 0.42rem 0.45rem !important; font-size: 0.7rem !important; }
            .glass-card { padding: 0.5rem !important; }
            .stat-card { padding: 0.5rem !important; }
        }

        /* 持倉分布圖：現金 / 加密 / 未上市 三列輸入 + 勾選 grid（v15.061：手機直向修復） */
        .pie-input-grid {
            display: grid;
            grid-template-columns: max-content 120px 80px auto;
            column-gap: 0.5rem;
            row-gap: 0.45rem;
            align-items: center;
        }
        @media (max-width: 540px) {
            .pie-input-grid {
                grid-template-columns: max-content 1fr;
            }
            /* 提示欄（每組第 3 個 child = 4n-1）獨立成行 */
            .pie-input-grid > :nth-child(4n-1) {
                grid-column: 1 / -1;
                justify-self: start;
                font-size: 0.72rem;
            }
            /* 勾選 label（每組第 4 個 child = 4n）獨立成行 */
            .pie-input-grid > :nth-child(4n) {
                grid-column: 1 / -1;
                justify-self: start;
            }
        }
    </style>
</head>
<body>
    <!-- 背景裝飾 -->
    <div style="position:fixed; top:0; left:0; right:0; bottom:0; background-image:linear-gradient(rgba(56,139,253,0.03) 1px, transparent 1px),linear-gradient(90deg, rgba(56,139,253,0.03) 1px, transparent 1px); background-size:50px 50px; pointer-events:none; z-index:0;"></div>
    <div style="position:fixed; top:10%; right:10%; width:300px; height:300px; background:radial-gradient(circle, rgba(37,99,235,0.1) 0%, transparent 70%); border-radius:50%; filter:blur(60px); pointer-events:none; z-index:0; animation:float 6s ease-in-out infinite;"></div>
    <div style="position:fixed; bottom:20%; left:5%; width:400px; height:400px; background:radial-gradient(circle, rgba(59,130,246,0.1) 0%, transparent 70%); border-radius:50%; filter:blur(80px); pointer-events:none; z-index:0; animation:float 8s ease-in-out infinite reverse;"></div>

    <div style="max-width:1200px; margin:0 auto; position:relative; z-index:1;">
        
        <!-- Header -->
        <div style="position:fixed; top:0.5rem; left:0.5rem; z-index:9999; font-size:0.7rem; color:rgba(255,255,255,0.5); font-family:monospace; pointer-events:none;">v15.900</div>
        <div id="pending-push-indicator" style="position:fixed; top:1.8rem; left:0.5rem; z-index:9999; font-size:0.72rem; color:#fbbf24; font-family:monospace; display:none; background:rgba(251,191,36,0.15); padding:2px 8px; border-radius:4px; border:1px solid rgba(251,191,36,0.3); cursor:pointer;" title="點此立即重試推送" onclick="_retryPushNow()">⚠ <span id="pending-push-count">0</span> 筆改動尚未同步</div>
        <div id="main-header" style="margin-bottom:1.25rem; text-align:center; padding-top:2.5rem;">
            <div id="main-header-wrap" style="display:inline-block; position:relative; padding:1rem 2rem; background:linear-gradient(135deg, rgba(30,58,110,0.25) 0%, rgba(18,38,80,0.15) 100%); border-radius:20px; border:1.5px solid rgba(56,139,253,0.2); box-shadow:0 0 40px rgba(37,99,235,0.1); margin-bottom:0.5rem;">
                <h1 id="main-title" style="color:#60a5fa; font-size:2.5rem; font-weight:900; margin:0 0 0.25rem 0; text-transform:uppercase; letter-spacing:3px; text-shadow:0 0 20px rgba(56,139,253,0.5); background:linear-gradient(135deg, #93c5fd 0%, #60a5fa 50%, #93c5fd 100%); -webkit-background-clip:text; -webkit-text-fill-color:transparent; background-size:200% auto; animation:shimmer 3s linear infinite;">Portfolio Tracker</h1>
                <div class="subtitle" style="display:flex; align-items:center; justify-content:center; gap:0.5rem; color:#60a5fa; font-size:0.9rem; font-weight:500; letter-spacing:2px; text-transform:uppercase;">台股 • 美股 • 港股 持倉管理系統</div>
            </div>
        </div>

        <!-- Tab Navigation -->
        <div style="display:flex; gap:0; margin-bottom:0; border-bottom:1.5px solid rgba(56,139,253,0.15); flex-wrap:wrap;">
            <button class="tab-btn active" id="tab-btn-1" onclick="switchTab(1)"><i class="ic">≡</i> 持倉管理</button>
            <button class="tab-btn" id="tab-btn-2" onclick="switchTab(2)"><i class="ic">△</i> 基本面</button>
            <button class="tab-btn" id="tab-btn-3" onclick="switchTab(3)"><i class="ic">◇</i> 技術面</button>
            <button class="tab-btn" id="tab-btn-4" onclick="switchTab(4)"><i class="ic">▣</i> 財報分析</button>
            <button class="tab-btn" id="tab-btn-5" onclick="switchTab(5)"><i class="ic">◎</i> 總體經濟</button>
            <button class="tab-btn" id="tab-btn-6" onclick="switchTab(6)"><i class="ic">◈</i> 已實現損益</button>
            <button class="tab-btn" id="tab-btn-7" onclick="switchTab(7)"><i class="ic">▦</i> 存款</button>
        </div>

        <!-- Tab 1: Holdings -->
        <div id="tab-pane-1" class="tab-pane active" style="padding-top:1.5rem;">

        <!-- Stats -->
        <div style="display:flex; justify-content:flex-end; align-items:center; gap:0.4rem; margin-bottom:0.4rem; flex-wrap:wrap;">
            <!-- 幣別切換 -->
            <div style="display:inline-flex;align-items:center;border:1px solid rgba(100,116,139,0.3);border-radius:8px;overflow:hidden;">
                <button id="currency-usd" onclick="setCurrency('USD')" style="padding:0.3rem 0.65rem;background:rgba(15,30,60,0.5);border:none;border-right:1px solid rgba(100,116,139,0.2);font-weight:700;font-size:0.78rem;color:#f1f5f9;cursor:pointer;">$ USD</button>
                <button id="currency-twd" onclick="setCurrency('TWD')" style="padding:0.3rem 0.65rem;background:rgba(15,30,60,0.5);border:none;font-weight:700;font-size:0.78rem;color:#f1f5f9;cursor:pointer;">NT$ TWD</button>
            </div>
            <!-- 字體大小 -->
            <div style="display:inline-flex;align-items:center;background:rgba(15,30,60,0.5);border:1px solid rgba(100,116,139,0.3);border-radius:8px;overflow:hidden;">
                <button onclick="adjustFontSize(-1)" title="縮小字體"
                    style="padding:0.3rem 0.55rem;background:none;border:none;border-right:1px solid rgba(100,116,139,0.2);color:#f1f5f9;font-weight:800;font-size:0.78rem;cursor:pointer;line-height:1;">A-</button>
                <span id="font-size-label" style="font-size:0.72rem;color:#a8bdd0;padding:0 0.45rem;min-width:2.8em;text-align:center;">16px</span>
                <button onclick="adjustFontSize(1)" title="放大字體"
                    style="padding:0.3rem 0.55rem;background:none;border:none;border-left:1px solid rgba(100,116,139,0.2);color:#f1f5f9;font-weight:800;font-size:0.78rem;cursor:pointer;line-height:1;">A+</button>
            </div>
            <!-- 字型切換 -->
            <button id="font-toggle-btn" onclick="toggleFont()" title="切換字型"
                style="background:rgba(15,30,60,0.5);border:1px solid rgba(100,116,139,0.3);border-radius:8px;padding:0.3rem 0.6rem;cursor:pointer;display:inline-flex;align-items:center;gap:0.3rem;font-size:0.78rem;color:#f1f5f9;transition:all 0.2s;text-transform:none;letter-spacing:0;">
                <span style="font-size:0.9rem;font-weight:700;font-family:serif;">Aa</span>
                <span id="font-toggle-label" style="font-size:0.75rem;">預設字型</span>
            </button>
            <button id="privacy-btn" onclick="togglePrivacy()" title="點擊隱藏敏感金額"
                class="pv-toggle-btn"
                style="background:rgba(15,30,60,0.5);border:1px solid rgba(100,116,139,0.3);border-radius:8px;padding:0.3rem 0.6rem;cursor:pointer;display:inline-flex;align-items:center;gap:0.3rem;font-size:0.78rem;color:#f1f5f9;transition:all 0.2s;">
                <span style="position:relative;display:inline-block;font-size:0.95rem;line-height:1;color:#93c5fd;">
                    ◉
                    <span id="privacy-slash" class="pv-slash-icon" style="display:none;position:absolute;left:-2px;right:-2px;top:48%;border-top:2.5px solid #f1f5f9;transform:rotate(-30deg);pointer-events:none;"></span>
                </span>
                <span style="font-size:0.75rem;color:#f1f5f9;">隱私</span>
            </button>
        </div>
        <div id="stats-grid" style="display:grid; grid-template-columns:repeat(auto-fit, minmax(220px, 1fr)); gap:1.5rem; margin-bottom:2rem;"></div>

        <!-- Exchange Rate Controls -->
        <div style="display:flex; gap:0.75rem; margin-bottom:1rem; align-items:center; flex-wrap:wrap;">
            <label style="color:#60a5fa; font-size:0.85rem; font-weight:600; white-space:nowrap;"><i class="ic">⇄</i> 匯率設定：</label>
            <div style="display:flex; align-items:center; gap:0.4rem;">
                <span style="color:#a8bdd0; font-size:0.85rem; white-space:nowrap;">USD/TWD</span>
                <input id="input-usd-twd" type="number" step="0.01" value="31.50" style="width:90px; padding:0.4rem 0.5rem; font-size:0.85rem;" onchange="applyManualRates()">
            </div>
            <div style="display:flex; align-items:center; gap:0.4rem;">
                <span style="color:#a8bdd0; font-size:0.85rem; white-space:nowrap;">HKD/TWD</span>
                <input id="input-hkd-twd" type="number" step="0.001" value="4.050" style="width:90px; padding:0.4rem 0.5rem; font-size:0.85rem;" onchange="applyManualRates()">
            </div>
            <button onclick="fetchLiveRates(this)" style="padding:0.4rem 0.9rem; background:rgba(16,185,129,0.15); color:#10b981; border:1px solid rgba(16,185,129,0.35); border-radius:8px; font-weight:600; font-size:0.82rem; text-transform:none; letter-spacing:0;">↻ 抓即時匯率</button>
            <button onclick="showFxTable(event)" style="padding:0.4rem 0.75rem; background:rgba(96,165,250,0.12); color:#60a5fa; border:1px solid rgba(96,165,250,0.3); border-radius:8px; font-weight:600; font-size:0.82rem; text-transform:none; letter-spacing:0;">≡ 匯率表</button>
            <span id="rate-source" style="color:#7e93a6; font-size:0.78rem;"></span>
        </div>
        <!-- 匯率表彈出視窗 -->
        <div id="fx-table-popup" onclick="hideFxTable()" style="display:none; position:fixed; inset:0; z-index:8888; background:rgba(0,0,0,0.45); align-items:center; justify-content:center;">
            <div onclick="event.stopPropagation()" style="background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,rgba(23,37,64,0.98) 100%); border:1px solid rgba(96,165,250,0.25); border-radius:16px; padding:1.5rem 1.75rem; min-width:260px; box-shadow:0 20px 60px rgba(0,0,0,0.6);">
                <div style="display:flex; align-items:center; justify-content:space-between; margin-bottom:1rem; gap:0.5rem;">
                    <span id="fx-table-title" style="color:#60a5fa; font-size:1rem; font-weight:700;"><i class="ic">⇄</i> 各幣 → TWD</span>
                    <div style="display:flex; align-items:center; gap:0.5rem;">
                        <button id="fx-dir-btn" onclick="toggleFxDirection()" style="padding:0.25rem 0.6rem; background:rgba(96,165,250,0.12); color:#60a5fa; border:1px solid rgba(96,165,250,0.3); border-radius:6px; font-size:0.78rem; font-weight:600; cursor:pointer; text-transform:none; letter-spacing:0;">⇄ 反向</button>
                        <button onclick="hideFxTable()" style="background:none; border:none; color:#7e93a6; font-size:1.2rem; cursor:pointer; padding:0; line-height:1;">✕</button>
                    </div>
                </div>
                <div id="fx-table-body" style="display:flex; flex-direction:column; gap:0.45rem;"></div>
                <div id="fx-table-time" style="margin-top:0.9rem; color:#607585; font-size:0.72rem; text-align:right;"></div>
            </div>
        </div>

        <!-- Action Buttons -->
        <div style="display:flex; gap:1rem; margin-bottom:0.5rem; flex-wrap:wrap;">
            <button onclick="showImportConfirm()" style="flex:1; min-width:170px; padding:0.75rem 1.5rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-weight:600; display:flex; align-items:center; justify-content:center; gap:0.5rem;"><span style="font-size:1rem;">↑</span>匯入持倉數據</button>
            <button onclick="exportHoldings()" style="flex:1; min-width:150px; padding:0.75rem 1.5rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-weight:600; display:flex; align-items:center; justify-content:center; gap:0.5rem;">↓ 匯出持倉數據</button>
            <button onclick="refreshAllData()" id="refresh-btn" style="flex:1; min-width:180px; padding:0.75rem 1.5rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-weight:600; display:flex; align-items:center; justify-content:center; gap:0.5rem;"><span id="refresh-icon" style="display:inline-block;">↻</span><span id="refresh-text">一鍵更新報價 + 匯率</span></button>
            <button onclick="manualPriceReview()" style="flex:1; min-width:140px; padding:0.75rem 1.5rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-weight:600;">✎ 手動輸入報價</button>
        </div>
        <!-- 自動更新狀態列 -->
        <div id="auto-refresh-status" style="display:none; text-align:right; font-size:0.75rem; color:#7e93a6; margin-bottom:1.5rem; padding-right:0.25rem;">
            ↻ 每分鐘自動更新 ｜ 最後更新：<span id="auto-refresh-time" style="color:#10b981; font-weight:600;">--:--:--</span>
            ｜ 下次更新：<span id="auto-refresh-countdown" style="color:#60a5fa; font-weight:600;">60</span>s
        </div>

        <!-- Pie Chart -->
        <div id="pie-section" class="glass-card" style="padding:2rem; margin-bottom:2rem; display:none;">
            <!-- 總資產列（最頂部）-->
            <div id="total-assets-bar" style="margin-bottom:1.25rem; padding:0.5rem 0.9rem; background:rgba(34,197,94,0.07); border:1px solid rgba(34,197,94,0.2); border-radius:8px; display:none; align-items:center; gap:0.4rem; flex-wrap:wrap;">
                <span style="color:#22c55e;font-size:0.82rem;font-weight:700;"><i class="ic">◈</i> 總資產</span>
                <span style="color:#607585;font-size:0.76rem;">(TWD)</span>
                <span style="color:#7e93a6;font-size:0.78rem;">　庫存</span>
                <span id="ta-stock" class="mono" style="color:#f1f5f9;font-size:0.85rem;font-weight:700;"></span>
                <span style="color:#7e93a6;font-size:0.78rem;">＋ 現金</span>
                <span id="ta-cash" class="mono" style="color:#f1f5f9;font-size:0.85rem;font-weight:700;"></span>
                <span id="ta-crypto-wrap" style="display:none; align-items:center; gap:0.4rem;">
                    <span style="color:#7e93a6;font-size:0.78rem;">＋ 加密</span>
                    <span id="ta-crypto" class="mono" style="color:#f1f5f9;font-size:0.85rem;font-weight:700;"></span>
                </span>
                <span id="ta-moxa-wrap" style="display:none; align-items:center; gap:0.4rem;">
                    <span style="color:#7e93a6;font-size:0.78rem;">＋ 未上市</span>
                    <span id="ta-moxa" class="mono" style="color:#f1f5f9;font-size:0.85rem;font-weight:700;"></span>
                </span>
                <span style="color:#7e93a6;font-size:0.78rem;">＝</span>
                <span id="ta-total" class="mono" style="color:#f1f5f9;font-size:0.95rem;font-weight:800;"></span>
            </div>
            <!-- 標題列 + 輸入欄 -->
            <div style="display:flex; align-items:flex-start; justify-content:space-between; flex-wrap:wrap; gap:0.75rem; margin-bottom:1.25rem;">
                <h2 style="color:#f1f5f9; font-size:1.25rem; font-weight:600; margin:0; padding-top:0.2rem;">持倉分布圖</h2>
                <!-- Grid 4欄：標籤 | 輸入框 | 提示/空白 | 打勾 → 三列完全對齊（v15.061 加 class 以套用 mobile media query） -->
                <div class="pie-input-grid">
                    <!-- 現金列（從存款頁籤自動計算） -->
                    <span style="color:#a8bdd0; font-size:0.85rem; white-space:nowrap;">現金（TWD）</span>
                    <span id="cash-twd-display" class="mono pv-field" style="width:100%; padding:0.3rem 0.55rem; background:rgba(15,23,42,0.3); border:1px solid rgba(148,163,184,0.1); border-radius:6px; color:#f1f5f9; font-size:0.85rem; box-sizing:border-box; display:inline-block; min-height:1.8rem;">0</span>
                    <span onclick="switchTab(7)" style="color:#3b82f6;font-size:0.72rem;cursor:pointer;white-space:nowrap;" title="前往存款頁籤">→ 存款</span>
                    <label id="cash-pie-label" title="勾選後圓餅圖會納入現金部位" style="display:inline-flex;align-items:center;gap:0.35rem;cursor:pointer;user-select:none;padding:0.2rem 0.55rem;background:rgba(34,197,94,0.08);border:1px solid rgba(34,197,94,0.25);border-radius:6px;">
                        <input type="checkbox" id="cash-pie-cb" onchange="saveCash(); renderAll();" style="width:14px;height:14px;accent-color:#22c55e;cursor:pointer;">
                        <span id="cash-pie-cb-label" style="font-size:0.8rem;font-weight:600;color:#7e93a6;white-space:nowrap;">含現金</span>
                    </label>
                    <!-- 加密列 -->
                    <span style="color:#a8bdd0; font-size:0.85rem; white-space:nowrap;">加密（TWD）</span>
                    <input type="number" id="crypto-twd-input" min="0" placeholder="0" onchange="saveCrypto(); renderAll();" class="pv-field"
                        style="width:100%; padding:0.3rem 0.55rem; background:rgba(15,23,42,0.5); border:1px solid rgba(148,163,184,0.2); border-radius:6px; color:#f1f5f9; font-size:0.85rem; box-sizing:border-box;">
                    <span id="crypto-usdt-hint" class="pv-hint" style="color:#607585; font-size:0.75rem; white-space:nowrap;"></span>
                    <label id="crypto-pie-label" title="勾選後圓餅圖會納入加密倉位" style="display:inline-flex;align-items:center;gap:0.35rem;cursor:pointer;user-select:none;padding:0.2rem 0.55rem;background:rgba(34,197,94,0.08);border:1px solid rgba(34,197,94,0.25);border-radius:6px;">
                        <input type="checkbox" id="crypto-pie-cb" onchange="saveCrypto(); renderAll();" style="width:14px;height:14px;accent-color:#22c55e;cursor:pointer;">
                        <span id="crypto-pie-cb-label" style="font-size:0.8rem;font-weight:600;color:#7e93a6;white-space:nowrap;">含加密</span>
                    </label>
                    <!-- MOXA 列 -->
                    <span style="color:#a8bdd0; font-size:0.85rem; white-space:nowrap;">未上市股票（TWD）</span>
                    <input type="number" id="moxa-twd-input" min="0" placeholder="0" onchange="saveMoxa(); renderAll();" class="pv-field"
                        style="width:100%; padding:0.3rem 0.55rem; background:rgba(15,23,42,0.5); border:1px solid rgba(148,163,184,0.2); border-radius:6px; color:#f1f5f9; font-size:0.85rem; box-sizing:border-box;">
                    <span></span>
                    <label id="moxa-pie-label" title="勾選後圓餅圖會納入未上市股票部位" style="display:inline-flex;align-items:center;gap:0.35rem;cursor:pointer;user-select:none;padding:0.2rem 0.55rem;background:rgba(34,197,94,0.08);border:1px solid rgba(34,197,94,0.25);border-radius:6px;">
                        <input type="checkbox" id="moxa-pie-cb" onchange="saveMoxa(); renderAll();" style="width:14px;height:14px;accent-color:#22c55e;cursor:pointer;">
                        <span id="moxa-pie-cb-label" style="font-size:0.8rem;font-weight:600;color:#7e93a6;white-space:nowrap;">含未上市</span>
                    </label>
                </div>
            </div>
            <div style="display:grid; grid-template-columns:repeat(auto-fit, minmax(300px, 1fr)); gap:2rem; align-items:start;">
                <div><canvas id="pieCanvas" width="400" height="400"></canvas></div>
                <div style="padding-top:0;">
                    <h3 style="color:#60a5fa; font-size:1.1rem; font-weight:700; margin:0 0 0.6rem 0; text-transform:uppercase; letter-spacing:1px;">持倉占比明細</h3>
                    <div id="pie-legend" style="display:flex; flex-direction:column; gap:0.15rem; max-height:400px; overflow-y:auto; padding-right:0.5rem;"></div>
                </div>
            </div>
        </div>

        <!-- Trade Form -->
        <div class="glass-card" style="padding:2rem; margin-bottom:2rem;">
            <div style="display:flex; align-items:center; justify-content:space-between; flex-wrap:wrap; gap:0.6rem; margin-bottom:1.5rem;">
                <div style="display:flex; gap:0; border-radius:12px; overflow:hidden; border:2px solid rgba(148,163,184,0.15); width:fit-content;">
                    <button onclick="setTradeType('buy')" id="buy-btn" style="padding:0.6rem 2rem; background:linear-gradient(135deg, #10b981 0%, #059669 100%); color:#fff; font-weight:700; font-size:1rem;">▲ 買入</button>
                    <button onclick="setTradeType('sell')" id="sell-btn" style="padding:0.6rem 2rem; background:rgba(15,30,60,0.6); color:#7e93a6; font-weight:700; font-size:1rem;">▼ 賣出</button>
                </div>
                <div style="display:flex; align-items:center; gap:0.4rem; flex-wrap:wrap;">
                    <button onclick="undoLastAction()" title="還原上一步" style="padding:0.45rem 0.75rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-size:0.82rem; font-weight:600; text-transform:none; letter-spacing:0; cursor:pointer;">↩ 上一步 <span id="undo-count">(0)</span></button>
                    <button onclick="redoAction()" id="redo-btn" title="重做下一步" disabled style="padding:0.45rem 0.75rem; background:rgba(56,139,253,0.1); color:#60a5fa; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-size:0.82rem; font-weight:600; text-transform:none; letter-spacing:0; cursor:pointer; opacity:0.4;">↪ 下一步 <span id="redo-count">(0)</span></button>
                </div>
            </div>
            <p id="trade-hint" style="color:#7e93a6; font-size:0.85rem; margin-bottom:1.5rem; margin-top:-0.5rem;">買入時若代碼已存在將自動加倉並重算加權平均成本</p>
            <div id="trade-form-grid" style="display:grid; grid-template-columns:repeat(auto-fit, minmax(180px, 1fr)); gap:1rem;">
                <div><label style="color:#cbd5e1; font-size:0.85rem; margin-bottom:0.5rem; display:block;">市場</label><select id="form-market" onchange="onMarketChange(this.value)"><option value="US">🇺🇸 美股</option><option value="TW">🇹🇼 台股</option><option value="HK">🇭🇰 港股</option></select></div>
                <div><label style="color:#cbd5e1; font-size:0.85rem; margin-bottom:0.5rem; display:block;">股票代碼 *</label><input id="form-symbol" type="text" placeholder="例: AAPL, 2330, 0700" style="text-transform:uppercase;" oninput="onSymbolInput(this.value)"></div>
                <div><label id="form-qty-label" style="color:#cbd5e1; font-size:0.85rem; margin-bottom:0.5rem; display:block;">買入股數 *</label><input id="form-quantity" type="number" step="0.0001" placeholder="數量"></div>
                <div><label id="form-price-label" style="color:#cbd5e1; font-size:0.85rem; margin-bottom:0.5rem; display:block;">買入價格 * <span id="form-price-ccy" style="color:#60a5fa; font-weight:700;">(USD)</span></label><input id="form-cost" type="number" step="0.0001" placeholder="此次買入均價"></div>
            </div>
            <button id="submit-btn" onclick="addHolding()" style="margin-top:1.5rem; width:100%; padding:0.85rem; background:linear-gradient(135deg, #10b981 0%, #059669 100%); color:#fff; font-weight:700; font-size:1rem;">▲ 確認買入</button>
        </div>

        <!-- Holdings Table -->
        <div id="table-section" class="glass-card" style="padding:2rem; margin-bottom:2rem; display:none;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:1.25rem; flex-wrap:wrap; gap:0.5rem;">
                <h2 style="color:#f1f5f9; font-size:1.25rem; font-weight:600; margin:0;"><i class="ic">≡</i> 持倉一覽</h2>
                <div style="display:flex; align-items:center; gap:0.75rem; flex-wrap:wrap;">
                    <button id="toggle-table-btn" onclick="toggleTableVisible()" style="padding:0.4rem 0.85rem;background:rgba(30,58,110,0.2);border:1.5px solid rgba(56,139,253,0.25);border-radius:10px;color:#60a5fa;font-size:0.82rem;font-weight:600;cursor:pointer;text-transform:none;">▲ 隱藏</button>
                    <div style="display:flex; gap:1rem; font-size:0.8rem; color:#7e93a6;"><span>USD/TWD <strong id="rate-usd-twd" style="color:#60a5fa;">31.50</strong></span><span>HKD/TWD <strong id="rate-hkd-twd" style="color:#60a5fa;">4.0500</strong></span></div>
                </div>
            </div>
            <div id="table-body-wrapper" style="overflow-x:auto; overflow-y:auto; max-height:65vh;"><table id="holdings-table" style="width:100%; border-collapse:collapse; font-size:0.9rem;"></table></div>
        </div>

        <!-- Holdings Detail -->
        <div class="glass-card" style="padding:2rem;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:1.5rem; flex-wrap:wrap; gap:1rem;">
                <div>
                    <h2 style="color:#f1f5f9; font-size:1.25rem; font-weight:600; margin:0;">持倉明細 (<span id="holdings-count">0</span>)</h2>
                    <div id="holdings-sync-time" style="color:#607585;font-size:0.72rem;margin-top:0.25rem;"></div>
                </div>
                <div style="display:flex; align-items:center; gap:0.5rem; flex-wrap:wrap;">
                    <button id="toggle-visible-btn" onclick="toggleHoldingsVisible()" style="padding:0.4rem 0.85rem;background:rgba(30,58,110,0.2);border:1.5px solid rgba(56,139,253,0.25);border-radius:10px;color:#60a5fa;font-size:0.82rem;font-weight:600;cursor:pointer;text-transform:none;">▲ 隱藏</button>
                    <button id="toggle-all-btn" onclick="toggleAllHoldings()" style="padding:0.4rem 0.85rem;background:rgba(30,58,110,0.2);border:1.5px solid rgba(56,139,253,0.25);border-radius:10px;color:#60a5fa;font-size:0.82rem;font-weight:600;cursor:pointer;text-transform:none;">展開全部 ▼</button>
                    <label id="persist-all-label" title="打勾後所有持倉下次開啟仍保留" style="display:flex;align-items:center;gap:0.5rem;cursor:pointer;user-select:none;padding:0.4rem 0.85rem;background:rgba(30,58,110,0.2);border:1.5px solid rgba(56,139,253,0.25);border-radius:10px;">
                        <input type="checkbox" id="persist-all-checkbox" onchange="toggleAllPersist(this.checked)" style="width:18px;height:18px;accent-color:#10b981;cursor:pointer;">
                        <span id="persist-all-text" style="font-size:0.85rem;font-weight:600;color:#7e93a6;"><i class="ic">◻</i> 下次開啟仍保留</span>
                    </label>
                </div>
            </div>
            <div id="holdings-list"></div>
        </div>

        <!-- 觀察清單 -->
        <div class="glass-card" style="padding:2rem; margin-top:1rem;">
            <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:0.9rem;flex-wrap:wrap;gap:0.75rem;">
                <h2 style="color:#f1f5f9;font-size:1.25rem;font-weight:600;margin:0;">觀察清單 (<span id="watchlist-count">0</span>)</h2>
                <button id="watchlist-toggle-btn" onclick="toggleWatchlistVisible()" style="padding:0.38rem 0.8rem;background:rgba(30,58,110,0.2);border:1.5px solid rgba(56,139,253,0.25);border-radius:10px;color:#60a5fa;font-size:0.82rem;font-weight:600;cursor:pointer;text-transform:none;letter-spacing:0;">▼ 顯示</button>
            </div>
            <div id="watchlist-body" style="display:none;">
                <!-- 輸入列 -->
                <div style="display:flex;gap:0.5rem;align-items:center;margin-bottom:0.85rem;flex-wrap:wrap;">
                    <input id="watchlist-symbol-input" type="text" placeholder="代號，如 AAPL"
                        onkeydown="if(event.key==='Enter')addToWatchlist()"
                        style="flex:1;min-width:120px;padding:0.5rem 0.75rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.25);border-radius:8px;color:#e2e8f0;font-size:0.88rem;text-transform:uppercase;outline:none;transition:border-color 0.2s;"
                        onfocus="this.style.borderColor='rgba(96,165,250,0.55)'" onblur="this.style.borderColor='rgba(56,139,253,0.25)'">
                    <select id="watchlist-market-select" style="padding:0.5rem 0.65rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.25);border-radius:8px;color:#a8bdd0;font-size:0.85rem;outline:none;cursor:pointer;">
                        <option value="US">美股</option>
                        <option value="TW">台股</option>
                        <option value="HK">港股</option>
                    </select>
                    <button onclick="addToWatchlist()" style="padding:0.5rem 1rem;background:linear-gradient(135deg,#2563eb,#1d4ed8);color:#fff;border:none;border-radius:8px;font-size:0.85rem;font-weight:700;cursor:pointer;white-space:nowrap;text-transform:none;letter-spacing:0;">+ 新增</button>
                </div>
                <!-- 清單 -->
                <div id="watchlist-list"></div>
            </div>
        </div>

        <!-- GitHub Gist 跨裝置同步 -->
        <div class="glass-card" style="padding:1rem 1.5rem; margin-top:1rem;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.65rem; flex-wrap:wrap; gap:0.5rem;">
                <label style="color:#60a5fa; font-size:0.85rem; font-weight:600;"><i class="ic">☁</i> 跨裝置同步（GitHub Gist）</label>
                <a href="https://github.com/settings/tokens/new?scopes=gist&description=PortfolioTracker"
                   target="_blank" rel="noopener"
                   style="font-size:0.78rem; color:#60a5fa; text-decoration:none;">取得 Token ↗</a>
            </div>
            <div style="display:grid; grid-template-columns:1fr auto; gap:0.5rem; margin-bottom:0.5rem;">
                <input id="gist-token" type="password" placeholder="GitHub Personal Access Token（gist 範圍）"
                    style="padding:0.55rem 0.75rem; background:rgba(6,13,26,0.9); border:1.5px solid rgba(56,139,253,0.25); border-radius:8px; color:#e2e8f0; font-size:0.82rem;">
                <input id="gist-id" type="text" placeholder="Gist ID（首次推送後自動填入）"
                    style="padding:0.55rem 0.75rem; background:rgba(6,13,26,0.9); border:1.5px solid rgba(56,139,253,0.25); border-radius:8px; color:#e2e8f0; font-size:0.82rem; min-width:200px;">
            </div>
            <div style="display:grid; grid-template-columns:1fr 1fr; gap:0.5rem;">
                <button onclick="gistPush()" style="padding:0.65rem; background:linear-gradient(135deg,#2563eb,#1d4ed8); color:#fff; border:none; border-radius:8px; font-weight:700; font-size:0.85rem; cursor:pointer; text-transform:none; letter-spacing:0;">
                    ⬆ 推送至雲端
                </button>
                <button onclick="gistPull()" style="padding:0.65rem; background:linear-gradient(135deg,#7c3aed,#6d28d9); color:#fff; border:none; border-radius:8px; font-weight:700; font-size:0.85rem; cursor:pointer; text-transform:none; letter-spacing:0;">
                    ⬇ 從雲端拉取
                </button>
            </div>
            <div id="gist-status" style="margin-top:0.45rem; font-size:0.78rem; color:#607585;"></div>
        </div>

        <!-- v15.079：本機回復點（標記最新版前的雲端資料快照） -->
        <div class="glass-card" id="rollback-card" style="display:none; padding:1rem 1.5rem; margin-top:1rem; border-color:rgba(251,191,36,0.4);">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.65rem; flex-wrap:wrap; gap:0.5rem;">
                <label style="color:#fbbf24; font-size:0.85rem; font-weight:600;"><i class="ic">↺</i> 本機回復點</label>
                <span style="font-size:0.72rem; color:#607585;">標記前雲端資料</span>
            </div>
            <div id="rollback-info" style="font-size:0.78rem; color:#94a3b8; margin-bottom:0.6rem;"></div>
            <div style="display:grid; grid-template-columns:1fr 1fr; gap:0.5rem;">
                <button onclick="_doRollback()" style="padding:0.55rem; background:linear-gradient(135deg,#f59e0b,#d97706); color:#fff; border:none; border-radius:8px; font-weight:700; font-size:0.82rem; cursor:pointer; text-transform:none; letter-spacing:0;">
                    回到標記前雲端資料
                </button>
                <button onclick="_dismissRollback()" style="padding:0.55rem; background:rgba(148,163,184,0.15); color:#94a3b8; border:1px solid rgba(148,163,184,0.3); border-radius:8px; font-weight:600; font-size:0.82rem; cursor:pointer; text-transform:none; letter-spacing:0;">
                    不需要
                </button>
            </div>
        </div>

        <!-- 錯誤日誌（v15.064） -->
        <div class="glass-card" style="padding:1rem 1.5rem; margin-top:1rem;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.65rem; flex-wrap:wrap; gap:0.5rem;">
                <label style="color:#60a5fa; font-size:0.85rem; font-weight:600;"><i class="ic">!</i> 錯誤日誌</label>
                <span style="font-size:0.72rem; color:#607585;">最多保留 50 筆</span>
            </div>
            <div style="display:grid; grid-template-columns:1fr auto auto; gap:0.5rem;">
                <button onclick="toggleErrorLog()" style="padding:0.5rem; background:rgba(56,139,253,0.12); color:#e2e8f0; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">
                    查看（<span id="error-log-count">0</span> 筆）
                </button>
                <button onclick="_copyErrorLog()" style="padding:0.5rem 0.85rem; background:rgba(96,165,250,0.12); color:#e2e8f0; border:1px solid rgba(96,165,250,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;" title="複製錯誤 JSON 到剪貼簿（給 codex review 用）">
                    複製
                </button>
                <button onclick="clearErrorLog()" style="padding:0.5rem 0.85rem; background:rgba(239,68,68,0.12); color:#e2e8f0; border:1px solid rgba(239,68,68,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">
                    清除
                </button>
            </div>
            <pre id="error-log-display" style="display:none; max-height:300px; overflow:auto; margin-top:0.6rem; padding:0.6rem; background:rgba(6,13,26,0.9); border:1px solid rgba(148,163,184,0.15); border-radius:6px; color:#a8bdd0; font-size:0.72rem; font-family:ui-monospace,monospace; white-space:pre-wrap; word-break:break-word;"></pre>
        </div>

        <!-- v15.077：本地資料夾同步（桌機限定，與 Gist 互斥） -->
        <div class="glass-card" id="local-sync-card" style="padding:1rem 1.5rem; margin-top:1rem;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.65rem; flex-wrap:wrap; gap:0.5rem;">
                <label style="color:#60a5fa; font-size:0.85rem; font-weight:600;"><i class="ic">≡</i> 本地資料夾同步（桌機限定）</label>
                <span id="local-sync-status" style="font-size:0.72rem; color:#607585;">未啟用</span>
            </div>
            <div style="font-size:0.78rem; color:#7e93a6; margin-bottom:0.5rem; line-height:1.55;">
                建議把選的資料夾放在 OneDrive / iCloud / Dropbox 同步資料夾，桌機間自動跨裝置。
                <span id="local-sync-dir-name" style="color:#a8bdd0; margin-left:0.4rem;"></span><br>
                <span style="color:#607585; font-size:0.72rem;">⚠ iOS Safari、Firefox、Safari 不支援；Gist 已設定時此功能停用。</span>
            </div>
            <div style="display:grid; grid-template-columns:repeat(2,1fr); gap:0.5rem;">
                <button id="local-sync-pick-btn" onclick="_localSyncPickDir()" style="padding:0.5rem; background:rgba(56,139,253,0.12); color:#e2e8f0; border:1px solid rgba(56,139,253,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">選擇資料夾</button>
                <button id="local-sync-push-btn" onclick="_localSyncPush({manual:true})" style="padding:0.5rem; background:rgba(16,185,129,0.12); color:#e2e8f0; border:1px solid rgba(16,185,129,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">推送至本地</button>
                <button id="local-sync-pull-btn" onclick="_localSyncPull({manual:true})" style="padding:0.5rem; background:rgba(124,58,237,0.12); color:#e2e8f0; border:1px solid rgba(124,58,237,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">從本地拉取</button>
                <button id="local-sync-off-btn" onclick="_localSyncDisable()" style="padding:0.5rem; background:rgba(239,68,68,0.12); color:#e2e8f0; border:1px solid rgba(239,68,68,0.3); border-radius:8px; font-size:0.82rem; cursor:pointer;">停用本地同步</button>
            </div>
        </div>

        <!-- 雲端 CSV 設定 -->
        <div class="glass-card" style="padding:1rem 1.5rem; margin-top:1rem;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.65rem; flex-wrap:wrap; gap:0.5rem;">
                <label style="color:#60a5fa; font-size:0.85rem; font-weight:600;"><i class="ic">≡</i> 雲端報價 CSV 路徑</label>
                <label style="display:flex; align-items:center; gap:0.4rem; cursor:pointer; user-select:none;">
                    <input type="checkbox" id="sheet-url-remember" onchange="saveSheetUrlSetting()"
                        style="width:15px; height:15px; accent-color:#3b82f6; cursor:pointer;">
                    <span id="sheet-url-remember-label" style="font-size:0.8rem; color:#7e93a6;">下次開啟記住此路徑</span>
                </label>
            </div>
            <div style="display:flex; gap:0.6rem; align-items:center; flex-wrap:wrap;">
                <input id="sheet-url" type="text" placeholder="貼上 Google Sheet CSV 連結 或 任何可公開存取的 CSV 網址"
                    onchange="saveSheetUrlSetting()"
                    style="flex:1; min-width:200px; padding:0.55rem 0.75rem; background:rgba(6,13,26,0.9); border:1.5px solid rgba(56,139,253,0.25); border-radius:8px; color:#e2e8f0; font-size:0.85rem;">
                <button onclick="fillDefaultSheetUrl()" title="填入原始共享報價 CSV 連結"
                    style="padding:0.5rem 0.75rem; background:rgba(16,185,129,0.12); color:#10b981; border:1px solid rgba(16,185,129,0.3); border-radius:8px; font-size:0.8rem; font-weight:600; white-space:nowrap; text-transform:none; letter-spacing:0;">
                    ≡ 原始報價 CSV
                </button>
                <button onclick="clearSheetUrl()" title="清除路徑"
                    style="padding:0.5rem 0.75rem; background:rgba(239,68,68,0.12); color:#ef4444; border:1px solid rgba(239,68,68,0.3); border-radius:8px; font-size:0.8rem; font-weight:600; white-space:nowrap; text-transform:none; letter-spacing:0;">
                    ✕ 清除
                </button>
            </div>
            <div id="sheet-url-status" style="margin-top:0.45rem; font-size:0.78rem; color:#607585;"></div>
        </div>
    </div>

        </div><!-- /tab-pane-1 -->

        <!-- 共用：更新按鈕列（Tab2/Tab3 皆顯示） -->
        <div id="analysis-ctrl" style="display:none; padding:1rem 0 0 0;">
            <div style="display:flex;gap:0.5rem;align-items:center;flex-wrap:wrap; margin-bottom:0.5rem;">
                <button onclick="loadAnalysis(event.shiftKey)" id="analysis-btn" title="Shift+Click 強制重新整理（忽略快取）" style="padding:0.7rem 1.5rem; background:linear-gradient(135deg,#2563eb 0%,#1d4ed8 100%); color:#fff; font-weight:700; border-radius:10px; font-size:0.9rem; text-transform:none; letter-spacing:0;">↻ 更新分析數據</button>
                <button onclick="setBackendUrl()" id="backend-btn" style="padding:0.7rem 1rem; background:rgba(99,102,241,0.15); color:#818cf8; border:1px solid rgba(99,102,241,0.35); border-radius:10px; font-size:0.82rem; font-weight:600; text-transform:none; letter-spacing:0;">⚙ 後端設定</button>
                <button onclick="forceUpdatePWA()" style="padding:0.7rem 1rem; background:rgba(239,68,68,0.15); color:#f87171; border:1px solid rgba(239,68,68,0.35); border-radius:10px; font-size:0.82rem; font-weight:600; text-transform:none; letter-spacing:0;">↻ 強制更新PWA</button>
                <button onclick="runDiagnostics()" style="padding:0.7rem 1rem; background:rgba(234,179,8,0.15); color:#fbbf24; border:1px solid rgba(234,179,8,0.35); border-radius:10px; font-size:0.82rem; font-weight:600; text-transform:none; letter-spacing:0;">⊙ 連線診斷</button>
                <span id="fund-source-time" style="font-size:0.78rem; color:#7e93a6;"></span>
                <span id="tech-source-time" style="font-size:0.78rem; color:#7e93a6;"></span>
                <span style="color:#7e93a6; font-size:0.78rem; margin-left:0.5rem;">槓桿 ETF 自動查詢原型股票</span>
            </div>
        </div>

        <!-- Tab 2: 基本面 -->
        <div id="tab-pane-2" class="tab-pane" style="padding-top:1rem;">
            <div class="glass-card" style="padding:1.5rem 2rem;">
                <h2 style="color:#f1f5f9; font-size:1.1rem; font-weight:600; margin:0 0 0.5rem 0;"><i class="ic">△</i> 基本面指標</h2>
                <div id="fund-backend-note" style="display:none; margin-bottom:0.75rem; padding:0.6rem 1rem; background:rgba(37,99,235,0.1); border:1px solid rgba(37,99,235,0.3); border-radius:8px; font-size:0.82rem; color:#3b82f6;">
                    ⚠ 基本面數據需要後端支援。請點「⚙ 後端設定」填入 Render.com 網址，或在本機執行 server.py。
                </div>
                <div style="overflow-x:auto; overflow-y:auto; max-height:65vh;">
                    <table style="width:100%; border-collapse:collapse; font-size:0.85rem; min-width:1450px;">
                        <thead>
                            <tr style="border-bottom:2px solid rgba(56,139,253,0.35);">
                                <th style="padding:0.55rem 0.6rem; text-align:left; color:#60a5fa; white-space:nowrap;">持倉代碼</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">下次財報</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">本益比 (PE)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">歷史均PE</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">預期本益比 (FPE)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">PEG</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">市銷率 (PS)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">股價淨值比 (PB)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">營收成長 (YoY)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">營收成長 (FWD)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">毛利率</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">營益率</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">EPS (本季預估)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">EPS (下季預估)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">EPS (近4季)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">EPS (全年預估)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:right; color:#60a5fa; white-space:nowrap;">EPS (明年預估)</th>
                            </tr>
                        </thead>
                        <tbody id="fund-tbody">
                            <tr><td colspan="17" style="text-align:center; padding:3rem; color:#7e93a6;">點擊「更新分析數據」開始載入</td></tr>
                        </tbody>
                    </table>
                </div>
            </div>
        </div><!-- /tab-pane-2 -->

        <!-- Tab 3: 技術面 -->
        <div id="tab-pane-3" class="tab-pane" style="padding-top:1rem;">
            <div class="glass-card" style="padding:1.5rem 2rem;">
                <h2 style="color:#f1f5f9; font-size:1.1rem; font-weight:600; margin:0 0 1rem 0;"><i class="ic">◇</i> 技術面指標</h2>
                <div style="overflow-x:auto; overflow-y:auto; max-height:65vh;">
                    <table style="width:100%; border-collapse:collapse; font-size:0.85rem; min-width:950px;">
                        <thead>
                            <tr style="border-bottom:2px solid rgba(56,139,253,0.35);">
                                <th style="padding:0.55rem 0.6rem; text-align:left; color:#60a5fa; white-space:nowrap;">持倉代碼</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">時 KD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">日 KD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">周 KD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">時 MACD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">日 MACD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">周 MACD</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">時 RSI(14)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">日 RSI(14)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap;">周 RSI(14)</th>
                                <th style="padding:0.55rem 0.6rem; text-align:center; color:#60a5fa; white-space:nowrap; background:rgba(56,139,253,0.1);">綜合評價</th>
                            </tr>
                        </thead>
                        <tbody id="tech-tbody">
                            <tr><td colspan="11" style="text-align:center; padding:3rem; color:#7e93a6;">點擊「更新分析數據」開始載入</td></tr>
                        </tbody>
                    </table>
                </div>
            </div>
        </div><!-- /tab-pane-3 -->

        <!-- Tab 4: 財報分析 -->
        <div id="tab-pane-4" class="tab-pane" style="padding-top:1rem;">
            <div class="glass-card" style="padding:1.5rem 2rem;">
                <div style="display:flex; align-items:center; justify-content:space-between; flex-wrap:wrap; gap:0.75rem; margin-bottom:1rem;">
                    <h2 style="color:#f1f5f9; font-size:1.1rem; font-weight:600; margin:0;"><i class="ic">▣</i> 近期財報分析 &amp; 券商評級</h2>
                    <div style="display:flex; gap:0.5rem; align-items:center; flex-wrap:wrap;">
                        <button onclick="loadEarningsAnalysis(true)" id="earnings-btn" style="padding:0.6rem 1.2rem; background:linear-gradient(135deg,#2563eb 0%,#1d4ed8 100%); color:#fff; font-weight:700; border-radius:10px; font-size:0.88rem; text-transform:none; letter-spacing:0;">↻ 載入分析</button>
                        <span id="earnings-status" style="font-size:0.78rem; color:#7e93a6;"></span>
                    </div>
                </div>
                <div style="margin-bottom:0.75rem; padding:0.6rem 1rem; background:rgba(59,130,246,0.08); border:1px solid rgba(59,130,246,0.2); border-radius:8px; font-size:0.8rem; color:#7e93a6;">
                    ※ 顯示各持倉標的近4季EPS財報（預估 vs 實際 / 驚喜幅度）、毛利率、營益率、券商評級共識、近30天評級異動及目標股價。
                </div>
                <div id="earnings-list">
                    <div style="text-align:center; padding:3rem; color:#7e93a6;">點擊「載入分析」開始抓取</div>
                </div>
            </div>
        </div><!-- /tab-pane-4 -->

        <!-- Tab 5: 總體經濟 -->
        <div id="tab-pane-5" class="tab-pane" style="padding-top:1rem;">
            <div class="glass-card" style="padding:1.5rem 2rem; margin-bottom:1rem;">
                <div style="display:flex; align-items:center; justify-content:space-between; flex-wrap:wrap; gap:0.75rem; margin-bottom:1rem;">
                    <h2 style="color:#f1f5f9; font-size:1.1rem; font-weight:600; margin:0;"><i class="ic">◎</i> 過去7天總體經濟數據</h2>
                    <div style="display:flex; gap:0.5rem; align-items:center; flex-wrap:wrap;">
                        <button onclick="loadMacro(true)" id="macro-btn" style="padding:0.6rem 1.2rem; background:linear-gradient(135deg,#2563eb 0%,#1d4ed8 100%); color:#fff; font-weight:700; border-radius:10px; font-size:0.88rem; text-transform:none; letter-spacing:0;">↻ 更新總經數據</button>
                        <span id="macro-status" style="font-size:0.78rem; color:#7e93a6;"></span>
                    </div>
                </div>
                <div id="macro-perf">
                    <div style="text-align:center; padding:3rem; color:#7e93a6;">點擊「更新總經數據」開始載入</div>
                </div>
            </div>
            <div class="glass-card" style="padding:1.5rem 2rem;">
                <h3 style="color:#f1f5f9; font-size:1rem; font-weight:600; margin:0 0 0.75rem 0;"><i class="ic">◆</i> 近期標的相關新聞</h3>
                <div id="macro-news">
                    <div style="text-align:center; padding:2rem; color:#7e93a6;">載入中...</div>
                </div>
            </div>
        </div><!-- /tab-pane-5 -->

        <!-- Tab 6: 已實現損益 -->
        <div id="tab-pane-6" class="tab-pane" style="padding-top:1rem;">
            <div class="glass-card" style="padding:2.5rem 2rem; text-align:center; margin-top:0.5rem;">
                <div style="font-size:2.2rem; color:#1e3a5f; margin-bottom:0.75rem;">◈</div>
                <div style="color:#7e93a6; font-size:0.95rem; font-weight:600;">尚無已實現損益紀錄</div>
                <div style="color:#607585; font-size:0.82rem; margin-top:0.35rem;">完成賣出交易後將自動記錄於此</div>
            </div>
        </div><!-- /tab-pane-6 -->

        <!-- Tab 7: 存款 -->
        <div id="tab-pane-7" class="tab-pane" style="padding-top:1rem;">
        </div><!-- /tab-pane-7 -->


    <!-- Modals -->
    <div id="import-modal" onclick="if(event.target===this)hideImportModal()" style="position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.75); display:none; align-items:center; justify-content:center; z-index:1000; padding:1rem;">
        <div class="glass-card" style="padding:2rem; max-width:720px; width:100%; max-height:90vh; display:flex; flex-direction:column;">
            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:1.25rem;">
                <h3 style="color:#60a5fa; font-size:1.3rem; margin:0;"><i class="ic">↑</i> 匯入持倉 CSV</h3>
                <button onclick="hideImportModal()" style="background:none; border:none; color:#a8bdd0; font-size:1.5rem; padding:0; line-height:1; cursor:pointer;">✕</button>
            </div>
            <label for="csv-file-input" id="csv-drop-zone"
                ondragover="event.preventDefault(); this.style.borderColor='#60a5fa'; this.style.background='rgba(56,139,253,0.08)';"
                ondragleave="this.style.borderColor='rgba(59,130,246,0.4)'; this.style.background='rgba(15,30,60,0.4)';"
                ondrop="handleCsvDrop(event)"
                style="display:block; border:2px dashed rgba(59,130,246,0.4); border-radius:14px; padding:2rem; text-align:center; cursor:pointer; background:rgba(15,30,60,0.4); transition:all 0.2s; margin-bottom:1rem; flex-shrink:0;">
                <div style="width:56px;height:56px;border-radius:14px;background:rgba(96,165,250,0.1);border:1.5px solid rgba(96,165,250,0.15);display:flex;align-items:center;justify-content:center;margin:0 auto 0.5rem;font-size:1.5rem;color:#60a5fa;">↑</div>
                <div style="color:#e2e8f0; font-weight:600; margin-bottom:0.25rem;">拖曳 CSV 到這裡，或點擊選擇檔案</div>
                <div style="color:#7e93a6; font-size:0.82rem;">支援「匯出持倉數據」產生的 CSV（含已實現損益紀錄）</div>
                <input id="csv-file-input" type="file" accept=".csv,text/csv" class="csv-file-input-hidden" onchange="handleCsvFile(this.files[0])">
            </label>
            <div style="background:rgba(59,130,246,0.08); border:1px solid rgba(59,130,246,0.2); border-radius:10px; padding:0.85rem 1rem; margin-bottom:1rem; font-size:0.82rem; color:#a8bdd0; flex-shrink:0;">
                <span style="color:#93c5fd; font-weight:600;">CSV 欄位順序（第一行為標題）：</span><br>
                <code style="color:#60a5fa;">Symbol, Market, Name, Quantity, Cost Price, Current Price</code><br>
                <code style="color:#e2e8f0; font-size:0.78rem;">NVDL, US, GraniteShares 2x NVDA, 750, 42.40, 74.17</code>
            </div>
            <div id="csv-preview-wrap" style="flex:1; overflow-y:auto; display:none; margin-bottom:1rem;">
                <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:0.75rem;">
                    <span id="csv-preview-count" style="color:#10b981; font-weight:600; font-size:0.9rem;"></span>
                    <span id="csv-preview-error" style="color:#ef4444; font-size:0.82rem;"></span>
                </div>
                <table id="csv-preview-table" style="width:100%; border-collapse:collapse; font-size:0.82rem;">
                    <thead><tr style="border-bottom:2px solid rgba(56,139,253,0.3);">
                        <th style="padding:0.4rem 0.5rem; text-align:left; color:#60a5fa;">代碼</th>
                        <th style="padding:0.4rem 0.5rem; color:#60a5fa;">市場</th>
                        <th style="padding:0.4rem 0.5rem; text-align:left; color:#60a5fa;">名稱</th>
                        <th style="padding:0.4rem 0.5rem; text-align:right; color:#60a5fa;">股數</th>
                        <th style="padding:0.4rem 0.5rem; text-align:right; color:#60a5fa;">成本價</th>
                        <th style="padding:0.4rem 0.5rem; text-align:right; color:#60a5fa;">現價</th>
                    </tr></thead>
                    <tbody id="csv-preview-tbody"></tbody>
                </table>
            </div>
            <div style="display:flex; gap:0.75rem; flex-shrink:0;">
                <button onclick="hideImportModal()" style="flex:1; background:rgba(71,85,105,0.3); color:#cbd5e1;">取消</button>
            </div>
        </div>
    </div>

    <div id="confirm-modal" onclick="if(event.target===this)hideConfirmModal()" style="position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.75); display:none; align-items:center; justify-content:center; z-index:2000;">
        <div class="glass-card" style="padding:2rem; max-width:420px; width:100%; text-align:center;">
            <div style="font-size:2rem; margin-bottom:1rem;">⚠️</div>
            <p id="confirm-text" style="color:#f1f5f9; line-height:1.7; margin-bottom:1.75rem;"></p>
            <div style="display:flex; gap:0.75rem;">
                <button onclick="confirmDelete()" style="flex:1; background:linear-gradient(135deg, #ef4444 0%, #dc2626 100%); color:#fff;">確認刪除</button>
                <button onclick="hideConfirmModal()" style="flex:1; background:rgba(71,85,105,0.4); color:#cbd5e1;">取消</button>
            </div>
        </div>
    </div>

    <div id="review-modal" onclick="if(event.target===this)hideReviewModal()" style="position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.8); display:none; align-items:center; justify-content:center; z-index:2000; padding:1rem;">
        <div class="glass-card" style="padding:2rem; max-width:700px; width:100%; max-height:85vh; overflow:hidden; display:flex; flex-direction:column;">
            <h3 style="color:#60a5fa; font-size:1.3rem; margin-bottom:0.5rem;"><i class="ic">≡</i> 股價更新審核</h3>
            <p style="color:#a8bdd0; font-size:0.85rem; margin-bottom:1rem;">點擊「新價格」欄位可直接修改</p>
            <div style="flex:1; overflow-y:auto; margin-bottom:1rem;">
                <table id="review-table" style="width:100%; border-collapse:collapse; font-size:0.85rem;"></table>
            </div>
            <div style="display:flex; gap:0.75rem;">
                <button onclick="applyReviewedPrices()" style="flex:1; background:linear-gradient(135deg, #10b981 0%, #059669 100%); color:#fff;">✓ 套用勾選的價格</button>
                <button onclick="hideReviewModal()" style="flex:1; background:rgba(71,85,105,0.4); color:#cbd5e1;">取消</button>
            </div>
        </div>
    </div>

    <script>
        // ==================== 全域變數 ====================
        let holdings = [];
        let history = [];
        let currency = 'TWD';
        let _allExpanded = false; // 預設收合
        let _holdingsHidden = true; // 持倉明細整體顯示狀態（預設隱藏）
        let _tableHidden = false; // 持倉一覽整體顯示狀態（預設顯示）
        let _tableSort = { by: 'value', dir: 'desc' }; // 持倉一覽排序狀態
        let _cardCache = {}; // 差異更新：{ [id]: fingerprint }
        let _cardExpanded = {}; // 差異更新：per-card 展開狀態
        let _saveStorageTimer = null; // 防抖計時器
        let watchlist = []; // 觀察清單
        let _watchlistHidden = true; // 觀察清單預設隱藏
        let tradeHistory = []; // 已實現損益紀錄
        let _realizedExpanded = {}; // 已實現損益 per-symbol 展開狀態
        let _realizedCurrency = 'native'; // 'native' = 原幣, 'TWD' = 全部轉台幣
        let _realizedDateFrom = ''; // 篩選起始日
        let _realizedDateTo   = ''; // 篩選截止日
        let marketSnapshots = []; // [{ date: 'YYYY-MM-DD', stockTWD: number }] 月度市值快照
        let _returnMode = 'year'; // 'month' | 'quarter' | 'year'

        function setTableSort(by) {
            if (_tableSort.by === by) {
                _tableSort.dir = _tableSort.dir === 'desc' ? 'asc' : 'desc';
            } else {
                _tableSort.by = by;
                _tableSort.dir = 'desc';
            }
            renderAll();
        }
        let _fxDirection = 'to_twd';   // 'to_twd' = 各幣→TWD；'from_twd' = TWD→各幣
        let _fxLastData  = null;        // 快取最後一次 fx 資料供切換方向時重繪

        function toggleTableVisible() {
            _tableHidden = !_tableHidden;
            const wrapper = document.getElementById('table-body-wrapper');
            const btn = document.getElementById('toggle-table-btn');
            if (wrapper) wrapper.style.display = _tableHidden ? 'none' : '';
            if (btn) btn.textContent = _tableHidden ? '▼ 顯示' : '▲ 隱藏';
        }

        function toggleHoldingsVisible() {
            _holdingsHidden = !_holdingsHidden;
            const list = document.getElementById('holdings-list');
            const visBtn = document.getElementById('toggle-visible-btn');
            const allBtn = document.getElementById('toggle-all-btn');
            if (list) list.style.display = _holdingsHidden ? 'none' : '';
            if (visBtn) visBtn.textContent = _holdingsHidden ? '▼ 顯示持倉' : '▲ 隱藏';
            if (allBtn) {
                allBtn.style.opacity = _holdingsHidden ? '0.35' : '1';
                allBtn.style.pointerEvents = _holdingsHidden ? 'none' : '';
            }
        }

        function toggleAllHoldings() {
            _allExpanded = !_allExpanded;
            document.querySelectorAll('[id^="holding-body-"]').forEach(el => {
                el.style.display = _allExpanded ? 'block' : 'none';
            });
            document.querySelectorAll('[id^="holding-chevron-"]').forEach(el => {
                el.textContent = _allExpanded ? '▲' : '▶';
            });
            const btn = document.getElementById('toggle-all-btn');
            if (btn) btn.textContent = _allExpanded ? '收合全部 ▲' : '展開全部 ▼';
        }
        function toggleHolding(id) {
            const body = document.getElementById('holding-body-' + id);
            const chevron = document.getElementById('holding-chevron-' + id);
            if (!body) return;
            const isVisible = body.style.display !== 'none';
            body.style.display = isVisible ? 'none' : 'block';
            if (chevron) chevron.textContent = isVisible ? '▶' : '▲';
        }
        let exchangeRates = { USD_TWD: 31.5, HKD_TWD: 4.05 };

        // ── 匯率快取（localStorage, 1hr TTL，大幅減少 open.er-api 用量）──
        // 策略：按需更新（On-Demand）。只有啟動/手動觸發時才檢查；快取 1hr 內直接用舊值。
        // 每分鐘自動更新報價時 (silentRefreshPrices) 若快取未過期，完全不打 API。
        // ── GitHub 全域快取（data/cache.json）跨裝置基本面快取 ──
        const GITHUB_CACHE_RAW = 'https://raw.githubusercontent.com/forsmileangel/portfolio-tracker/main/data/cache.json';
        const FUND_CACHE_TTL   = 2 * 60 * 60 * 1000; // 基本面：2小時
        let _globalCache       = null;
        let _globalCacheLoaded = false;
        let _globalCacheDirty  = false;

        async function _loadGlobalCache() {
            if (_globalCacheLoaded) return _globalCache;
            try {
                const r = await fetch(GITHUB_CACHE_RAW + '?_t=' + Date.now(), { cache: 'no-store' });
                _globalCache = r.ok ? await r.json() : { fundamentals: {} };
            } catch(_) {
                _globalCache = { fundamentals: {} };
            }
            if (!_globalCache.fundamentals) _globalCache.fundamentals = {};
            _globalCacheLoaded = true;
            return _globalCache;
        }

        async function _pushGlobalCache() {
            if (!_globalCacheDirty || !_globalCache) return;
            const base = _isLocal ? '' : (BACKEND_URL || null);
            if (base === null) return; // 無後端，無法回寫
            try {
                const r = await fetch(base + '/update-cache', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(_globalCache)
                });
                if (r.ok) _globalCacheDirty = false;
            } catch(_) {}
        }

        // #region Storage Keys & Freshness Helper (v15.063+)
        // ────────────────────────────────────────────────────────
        // v15.066：PWA 版本基準（每次 bump 版本要同步更新此常數）
        // 用於與網路上抓回的 HTML 版本字串比對；不同 → 提示重載
        // ────────────────────────────────────────────────────────
        const APP_VERSION = 'v15.900';

        // ────────────────────────────────────────────────────────
        // STORAGE_KEYS — 集中登記所有 localStorage key（v15.063 起）
        // 規則（詳見 .claude/rules/storage-keys.md）：
        //   1. 任何新增的 localStorage key 必須在此處登記
        //   2. key 字串值不可隨意 rename；rename 必須有 migration / rollback / 測試
        //   3. 本版採保守路線：純新增此物件作為「已知 key 清單」，既有 PT_*_KEY 常數不動
        // ────────────────────────────────────────────────────────
        const STORAGE_KEYS = Object.freeze({
            // 主要狀態
            state:            'pt_v13p_state',
            deposits:         'pt_deposits',
            tradeHistory:     'pt_trade_history',
            watchlist:        'pt_watchlist',
            snapshots:        'pt_snapshots',
            // 圓餅圖手動欄位
            cashLegacy:       'pt_v13_cash',          // 已棄用，向下相容保留
            cashPie:          'pt_cash_pie_cb',
            crypto:           'pt_crypto_twd',
            cryptoPie:        'pt_crypto_pie_cb',
            moxa:             'pt_moxa_twd',
            moxaPie:          'pt_moxa_pie_cb',
            // UI 偏好
            privacy:          'pt_privacy_mode',
            font:             'pt_font',
            fontSize:         'font_size',
            // Gist 同步
            gistToken:        'pt_gist_token_v15',
            gistId:           'pt_gist_id_v15',
            deviceId:         'pt_device_id',
            lastCloudRev:     'pt_last_cloud_revision',
            lastCloudTs:      'pt_last_cloud_updated_at',
            dirtyDomains:     'pt_dirty_domains',
            domainUpdatedAt:  'pt_domain_updated_at',
            localModifyTs:    'pt_local_modify_ts',
            pendingPushCount: 'pt_pending_push_count',
            lastPushError:    'pt_last_push_error',
            errorLog:         'pt_error_log_v1',     // v15.064：應用錯誤日誌（最多 50 筆）
            dailyPnlSnapshots:'pt_daily_pnl_snapshots_v1',  // v15.069 起（v15.071 起會同步進 Gist）
            marketQuoteMeta:  'pt_market_quote_meta_v1',    // v15.071/073：批次報價更新時間 + marketDate（v15.073 加）
            marketAnalysisMeta:'pt_market_analysis_meta_v1', // v15.073：runAnalysis 完成後 prevClose/prevPrevClose 對齊的 marketDate
            // v15.079：userDataHash + master flag tracking（純本機）
            lastUserDataHash:        'pt_last_user_data_hash_v1',
            processedMasterIds:      'pt_processed_master_ids_v1',
            rollbackSummary:         'pt_cloud_master_rollback_summary_v1',
            // v15.077：本地資料夾同步（FSA），桌機限定，獨立於 Gist 流程
            localSyncEnabled:        'pt_local_sync_enabled',
            localSyncFile:           'pt_local_sync_file',
            localSyncDirName:        'pt_local_sync_dir_name',
            localSyncBasePushedAt:   'pt_local_sync_base_pushed_at',
            localSyncLocalModifiedAt:'pt_local_sync_local_modified_at',
            localSyncDirtyDomains:   'pt_local_sync_dirty_domains',
            localSyncLastPushAt:     'pt_local_sync_last_push_at',
            localSyncLastPullAt:     'pt_local_sync_last_pull_at',
            localSyncLastError:      'pt_local_sync_last_error',
            localSyncDeviceId:       'pt_local_sync_device_id',
            // 快取
            fxCache:          'pt_fx_v1',
            analysisCache:    'pf_analysis_v8',
            qsCache:          'pf_qs_v5',
            macroCache:       'pf_macro_v1',
            // 後端
            backendUrl:       'backend_url',
        });

        // ────────────────────────────────────────────────────────
        // _freshnessColor — 依資料年齡決定顯示色（v15.063 起）
        // 用於基本面 / 技術面 / 匯率 時間戳：新鮮灰藍、接近過期橘、已過期紅
        // ────────────────────────────────────────────────────────
        function _freshnessColor(ageMs, freshMaxMs, staleMs) {
            if (ageMs == null || isNaN(ageMs)) return '#7e93a6';
            if (ageMs <= freshMaxMs) return '#7e93a6';   // 灰藍：新鮮
            if (ageMs <= staleMs)    return '#fbbf24';   // 橘：接近過期
            return '#ef4444';                            // 紅：已過期 / 明顯 stale
        }

        // ────────────────────────────────────────────────────────
        // v15.073：市場行事曆 + 交易日狀態機
        // 來源：TWSE「115 年市場開休市日期」、HKEX 2026 Securities Market Holiday Schedule、NYSE Holidays & Trading Hours
        // 設計：holidays 用 Set<'YYYY-MM-DD'>；週末由 _isTradingDay 內部判斷（不一定要列在 holidays）
        // 涵蓋 2026 全年；2027 之後年份回 null → 呼叫端 fallback 為純週末判斷
        // ────────────────────────────────────────────────────────
        const MARKET_CALENDARS = {
            TW: {
                tz: 'Asia/Taipei',
                openMin: 9*60, closeMin: 13*60+30,
                years: { 2026: true },
                holidays: new Set([
                    '2026-01-01',                                           // 元旦
                    '2026-02-12',                                            // v15.074：春節前一日，TWSE 列為市場無交易（僅辦結算交割）
                    '2026-02-13','2026-02-16','2026-02-17','2026-02-18',     // 農曆春節（連假）
                    '2026-02-19','2026-02-20',
                    '2026-02-27','2026-02-28',                               // 228 和平紀念日（含補假）
                    '2026-04-03','2026-04-06',                               // 兒童節 / 清明補假
                    '2026-05-01',                                           // 勞動節
                    '2026-06-19',                                           // 端午節
                    '2026-09-25',                                           // 中秋節
                    '2026-09-28',                                            // v15.074：教師節（依 TWSE 公告）
                    '2026-10-09','2026-10-10',                               // 國慶連假
                    '2026-10-26',                                            // v15.074：光復節補假（10/25 為週日）
                    '2026-12-25'                                             // v15.074：行憲紀念日
                ])
            },
            HK: {
                tz: 'Asia/Hong_Kong',
                openMin: 9*60+30, closeMin: 16*60+10,
                years: { 2026: true },
                holidays: new Set([
                    '2026-01-01',                                           // New Year's Day
                    '2026-02-17','2026-02-18','2026-02-19',                  // Lunar New Year (Tue~Thu)
                    '2026-04-03','2026-04-06','2026-04-07',                  // Good Friday / Easter Monday / Ching Ming
                    '2026-05-01',                                           // Labour Day
                    '2026-05-25',                                           // Buddha's Birthday
                    '2026-06-19',                                           // Tuen Ng (Dragon Boat)
                    '2026-07-01',                                           // HKSAR Establishment Day
                    '2026-09-26',                                           // Mid-Autumn Festival 翌日
                    '2026-10-01',                                           // National Day
                    '2026-10-19',                                           // Chung Yeung Festival
                    '2026-12-25'                                             // v15.074：移除 12/28（HKEX 公告無此日）
                ]),
                earlyClose: {                                                // v15.074：HKEX 半日市（12:00 收市）
                    '2026-02-16': 12*60,   // 農曆除夕
                    '2026-12-24': 12*60,   // Christmas Eve
                    '2026-12-31': 12*60    // New Year's Eve
                }
            },
            US: {
                tz: 'America/New_York',
                openMin: 9*60+30, closeMin: 16*60,
                years: { 2026: true },
                holidays: new Set([
                    '2026-01-01',          // New Year's Day
                    '2026-01-19',          // MLK Day
                    '2026-02-16',          // Presidents Day
                    '2026-04-03',          // Good Friday
                    '2026-05-25',          // Memorial Day
                    '2026-06-19',          // Juneteenth
                    '2026-07-03',          // Independence Day (observed; 7/4 為週六)
                    '2026-09-07',          // Labor Day
                    '2026-11-26',          // Thanksgiving
                    '2026-12-25'           // Christmas
                ]),
                earlyClose: {
                    // v15.074：移除原 '2026-07-02'（NYSE 2026 表未列為 early close；7/3 為 observed holiday 全日休市）
                    '2026-11-27': 13*60,   // Day after Thanksgiving
                    '2026-12-24': 13*60    // Christmas Eve
                }
            }
        };

        // 'YYYY-MM-DD' → 偏移 days 後的 'YYYY-MM-DD'（用 UTC 中午避開夏令時陷阱）
        function _shiftDate(dateStr, days) {
            const d = new Date(dateStr + 'T12:00:00Z');
            d.setUTCDate(d.getUTCDate() + days);
            const y = d.getUTCFullYear();
            const m = String(d.getUTCMonth() + 1).padStart(2, '0');
            const day = String(d.getUTCDate()).padStart(2, '0');
            return `${y}-${m}-${day}`;
        }
        // 是否是該市場的交易日：true=是、false=明確不是、null=calendar 不涵蓋年份（fallback 週末判斷由呼叫端決定）
        function _isTradingDay(market, dateStr) {
            const cal = MARKET_CALENDARS[market];
            if (!cal || !dateStr) return null;
            const d = new Date(dateStr + 'T12:00:00Z');
            if (isNaN(d.getTime())) return null;
            const wd = d.getUTCDay();   // 0=Sun, 6=Sat
            if (wd === 0 || wd === 6) return false;
            const yr = parseInt(dateStr.slice(0, 4), 10);
            if (!cal.years[yr]) {
                // 未涵蓋年份：用 v15.064 _recordAppError，60s 同 source 去重避免洗版
                try { _recordAppError && _recordAppError('calendar_unknown', new Error(`market=${market} year=${yr} not in MARKET_CALENDARS`)); } catch(_) {}
                return null;
            }
            return !cal.holidays.has(dateStr);
        }
        // 從 dateStr 向前找最近交易日；calendar unknown 回 null
        function _previousTradingDate(market, dateStr) {
            if (!dateStr) return null;
            let cursor = _shiftDate(dateStr, -1);
            for (let i = 0; i < 14; i++) {
                const r = _isTradingDay(market, cursor);
                if (r === true) return cursor;
                if (r === null) return null;
                cursor = _shiftDate(cursor, -1);
            }
            return null;
        }
        // 從 dateStr 向後找最近交易日；calendar unknown 回 null
        function _nextTradingDate(market, dateStr) {
            if (!dateStr) return null;
            let cursor = _shiftDate(dateStr, 1);
            for (let i = 0; i < 14; i++) {
                const r = _isTradingDay(market, cursor);
                if (r === true) return cursor;
                if (r === null) return null;
                cursor = _shiftDate(cursor, 1);
            }
            return null;
        }

        // ────────────────────────────────────────────────────────
        // v15.069：市場分類與市場時鐘（今日/昨日損益市場拆分用）
        // ────────────────────────────────────────────────────────

        // 持倉的市場分類：優先 h.market；fallback 用 symbol 判斷
        function _holdingMarketKey(h) {
            if (h && h.market === 'TW') return 'TW';
            if (h && h.market === 'HK') return 'HK';
            if (h && h.market === 'US') return 'US';
            const sym = (h && h.symbol) || '';
            if (sym.endsWith('.HK')) return 'HK';
            if (sym.endsWith('.TW') || /^\d{4,6}[A-Z]?$/i.test(sym)) return 'TW';
            return 'US';
        }

        // v15.073：由市場行事曆驅動的 session 計算
        // 回傳：{ market, tz, localDate, localHHMM, status, closeMin, lastCompletedTradingDate, nextTradingDate }
        // status: 'not_open' | 'open' | 'closed' | 'closed_or_holiday'
        // lastCompletedTradingDate：closed 時 = localDate；其他時 = 向前找的交易日；calendar unknown 時 fallback 用週末判斷
        function _marketSession(marketKey, now) {
            now = now || new Date();
            const cal = MARKET_CALENDARS[marketKey];
            const tz = (cal && cal.tz)
                     || (marketKey === 'TW' ? 'Asia/Taipei'
                       : marketKey === 'HK' ? 'Asia/Hong_Kong'
                       : 'America/New_York');
            const fmt = new Intl.DateTimeFormat('en-US', {
                timeZone: tz, weekday: 'short',
                year: 'numeric', month: '2-digit', day: '2-digit',
                hour: '2-digit', minute: '2-digit', hourCycle: 'h23'
            });
            const parts = {};
            for (const p of fmt.formatToParts(now)) parts[p.type] = p.value;
            const localDate = `${parts.year}-${parts.month}-${parts.day}`;
            const hh = parseInt(parts.hour, 10), mm = parseInt(parts.minute, 10);
            const minutes = hh * 60 + mm;

            const todayIsTrading = _isTradingDay(marketKey, localDate);
            const isWeekend = (parts.weekday === 'Sat' || parts.weekday === 'Sun');
            // calendar 未涵蓋年份 → null：fallback 為純週末判斷
            const tradingToday = (todayIsTrading === null) ? !isWeekend : todayIsTrading;

            // 開盤 / 收盤分鐘（含 US early close）
            const openMin  = (cal && cal.openMin)  ?? (marketKey === 'TW' ? 9*60     : marketKey === 'HK' ? 9*60+30  : 9*60+30);
            const closeMin = (cal && cal.earlyClose && cal.earlyClose[localDate])
                          || (cal && cal.closeMin)
                          || (marketKey === 'TW' ? 13*60+30 : marketKey === 'HK' ? 16*60+10 : 16*60);

            let status, lastCompletedTradingDate;
            if (!tradingToday) {
                status = 'closed_or_holiday';
                // calendar unknown 時 _previousTradingDate 回 null → 退路用 _shiftDate -1 直到非週末（最多 7 天）
                lastCompletedTradingDate = _previousTradingDate(marketKey, localDate)
                                        || _previousNonWeekendDate(localDate);
            } else if (minutes < openMin) {
                status = 'not_open';
                lastCompletedTradingDate = _previousTradingDate(marketKey, localDate)
                                        || _previousNonWeekendDate(localDate);
            } else if (minutes < closeMin) {
                status = 'open';
                lastCompletedTradingDate = _previousTradingDate(marketKey, localDate)
                                        || _previousNonWeekendDate(localDate);
            } else {
                status = 'closed';
                lastCompletedTradingDate = localDate;
            }

            return {
                market: marketKey, tz, localDate,
                localHHMM: `${parts.hour}:${parts.minute}`,
                status, closeMin,
                lastCompletedTradingDate,
                nextTradingDate: _nextTradingDate(marketKey, localDate)
            };
        }
        // 不依賴 calendar 的「向前找非週末」fallback（calendar unknown 年份用）
        function _previousNonWeekendDate(dateStr) {
            let cursor = _shiftDate(dateStr, -1);
            for (let i = 0; i < 7; i++) {
                const wd = new Date(cursor + 'T12:00:00Z').getUTCDay();
                if (wd !== 0 && wd !== 6) return cursor;
                cursor = _shiftDate(cursor, -1);
            }
            return null;
        }
        // 保留 _marketClock 為 alias，避免改太多既有 callers
        function _marketClock(marketKey, now) { return _marketSession(marketKey, now); }

        // 從 pf_analysis_v8 cache hydrate prevClose / prevPrevClose（v15.069 抽成函式）
        // 注意：marketOpenedToday 不 hydrate（時間敏感狀態，runAnalysis 會更新）
        function _hydrateDailyPnlCachesFromAnalysisCache() {
            try {
                const _rawCache = _loadCacheRaw();
                if (!_rawCache || !_rawCache.data) return;
                const _pc = window._prevCloseCache || {};
                const _ppc = window._prevPrevCloseCache || {};
                for (const sym in _rawCache.data) {
                    const d = _rawCache.data[sym];
                    if (d == null) continue;
                    if (d.prevClose != null     && _pc[sym]  == null) _pc[sym]  = d.prevClose;
                    if (d.prevPrevClose != null && _ppc[sym] == null) _ppc[sym] = d.prevPrevClose;
                }
                window._prevCloseCache     = _pc;
                window._prevPrevCloseCache = _ppc;
                if (window._marketOpenedToday == null) window._marketOpenedToday = {};
            } catch(_) {}
        }

        // ────────────────────────────────────────────────────────
        // v15.069：當日收盤快照（凍結）
        // 結構：pt_daily_pnl_snapshots_v1 = { version, markets: { TW: {marketDate, closedAt, source, pnlTWD, pnlUSD, holdings:[]}, HK:..., US:... } }
        // 不寫進 Gist；只在本機 localStorage
        // ────────────────────────────────────────────────────────
        // v15.070：snapshot schema v2 — markets[mk] = { current, previous } + lastCompleteDate
        function _emptyDailyPnlSnapshots() {
            return {
                version: 2,
                lastCompleteDate: null,
                markets: {
                    TW: { current: null, previous: null },
                    HK: { current: null, previous: null },
                    US: { current: null, previous: null }
                }
            };
        }
        function _loadDailyPnlSnapshots() {
            try {
                const raw = localStorage.getItem(STORAGE_KEYS.dailyPnlSnapshots);
                if (!raw) return _emptyDailyPnlSnapshots();
                const parsed = JSON.parse(raw);
                if (!parsed) return _emptyDailyPnlSnapshots();
                // v1 → v2 migration（v1 markets[mk] = snapshot 直接覆蓋）
                if (parsed.version === 1 && parsed.markets && typeof parsed.markets === 'object') {
                    const v2 = _emptyDailyPnlSnapshots();
                    for (const mk of ['TW', 'HK', 'US']) {
                        const old = parsed.markets[mk];
                        if (old && old.marketDate) v2.markets[mk].current = old;
                    }
                    // v15.072：補算 lastCompleteDate 並寫回 localStorage，避免每次開頁重跑 migration
                    v2.lastCompleteDate = _computeLastCompleteDate(v2.markets);
                    _saveDailyPnlSnapshots(v2);
                    return v2;
                }
                if (parsed.version !== 2) return _emptyDailyPnlSnapshots();
                if (!parsed.markets || typeof parsed.markets !== 'object') parsed.markets = {};
                for (const mk of ['TW', 'HK', 'US']) {
                    if (!parsed.markets[mk]) parsed.markets[mk] = { current: null, previous: null };
                }
                return parsed;
            } catch(_) {
                return _emptyDailyPnlSnapshots();
            }
        }
        // 計算 lastCompleteDate：三市場都有 fresh_after_close current snapshot 時，取最舊的
        // v15.071：只計 fresh，pending_quote 不算（舊資料 v15.070 沒 quoteStatus 視為 fresh，向下相容）
        function _computeLastCompleteDate(markets) {
            const _freshDate = (c) => {
                if (!c || !c.marketDate) return null;
                const st = c.quoteStatus || 'fresh_after_close';
                return st === 'fresh_after_close' ? c.marketDate : null;
            };
            const tw = _freshDate(markets.TW && markets.TW.current);
            const hk = _freshDate(markets.HK && markets.HK.current);
            const us = _freshDate(markets.US && markets.US.current);
            if (!tw || !hk || !us) return null;
            return [tw, hk, us].sort()[0];
        }
        function _saveDailyPnlSnapshots(snap) {
            try {
                localStorage.setItem(STORAGE_KEYS.dailyPnlSnapshots, JSON.stringify(snap));
            } catch(_) {}
        }

        // ────────────────────────────────────────────────────────
        // v15.071：市場批次報價時間（給 snapshot 新鮮度判斷使用）
        // 結構：{ TW: { lastQuoteAt: ISO, source: 'csv'|'yahoo'|'silent' }, HK:..., US:... }
        // 只有「批次報價更新流程」才 update，單一手動改價不寫
        // ────────────────────────────────────────────────────────
        function _loadMarketQuoteMeta() {
            try {
                const raw = localStorage.getItem(STORAGE_KEYS.marketQuoteMeta);
                if (!raw) return { TW: null, HK: null, US: null };
                const parsed = JSON.parse(raw);
                if (!parsed || typeof parsed !== 'object') return { TW: null, HK: null, US: null };
                return {
                    TW: parsed.TW || null,
                    HK: parsed.HK || null,
                    US: parsed.US || null
                };
            } catch(_) {
                return { TW: null, HK: null, US: null };
            }
        }
        function _markBatchQuoteRefresh(markets, source) {
            try {
                const meta = _loadMarketQuoteMeta();
                const ts = new Date().toISOString();
                const now = new Date();
                const arr = Array.isArray(markets) ? markets : [markets];
                for (const mk of arr) {
                    if (mk === 'TW' || mk === 'HK' || mk === 'US') {
                        // v15.073：marketDate = 該市場 lastCompletedTradingDate（不是日曆日）
                        // 收盤後刷 → marketDate=今天；週末/假日刷 → marketDate=最後交易日
                        const session = _marketSession(mk, now);
                        meta[mk] = {
                            lastQuoteAt: ts,
                            marketDate: session.lastCompletedTradingDate || null,
                            source: source || 'unknown'
                        };
                    }
                }
                localStorage.setItem(STORAGE_KEYS.marketQuoteMeta, JSON.stringify(meta));
            } catch(_) {}
        }
        // 各市場收盤時間（local time, minutes since midnight）— 跟 _marketClock 內的時段對齊
        const _MARKET_CLOSE_MIN = { TW: 13*60+30, HK: 16*60+10, US: 16*60 };

        // ────────────────────────────────────────────────────────
        // v15.073：market analysis meta — runAnalysis 完成後 prevClose / prevPrevClose 對齊到的 marketDate
        // 給 _captureDailyPnlSnapshot 跟 quote meta 一起雙重對齊驗證新鮮度
        // ────────────────────────────────────────────────────────
        function _loadMarketAnalysisMeta() {
            try {
                const raw = localStorage.getItem(STORAGE_KEYS.marketAnalysisMeta);
                if (!raw) return { TW: null, HK: null, US: null };
                const parsed = JSON.parse(raw);
                if (!parsed || typeof parsed !== 'object') return { TW: null, HK: null, US: null };
                return {
                    TW: parsed.TW || null,
                    HK: parsed.HK || null,
                    US: parsed.US || null
                };
            } catch(_) {
                return { TW: null, HK: null, US: null };
            }
        }
        function _markAnalysisRefresh(markets) {
            try {
                const meta = _loadMarketAnalysisMeta();
                const ts = new Date().toISOString();
                const now = new Date();
                const arr = Array.isArray(markets) ? markets : [markets];
                for (const mk of arr) {
                    if (mk === 'TW' || mk === 'HK' || mk === 'US') {
                        const session = _marketSession(mk, now);
                        meta[mk] = {
                            lastAnalyzedAt: ts,
                            marketDate: session.lastCompletedTradingDate || null
                        };
                    }
                }
                localStorage.setItem(STORAGE_KEYS.marketAnalysisMeta, JSON.stringify(meta));
            } catch(_) {}
        }
        // v15.072：把 lastQuoteAt（ISO）轉成「該市場時區」的 { date, minutes }
        // 給 _isQuoteFreshAfterClose 與 _captureDailyPnlSnapshot 的 backfill 路徑共用
        function _lastQuoteLocalInfo(marketKey, lastQuoteAt) {
            try {
                const tz = marketKey === 'TW' ? 'Asia/Taipei'
                         : marketKey === 'HK' ? 'Asia/Hong_Kong'
                         : 'America/New_York';
                const d = new Date(lastQuoteAt);
                if (isNaN(d.getTime())) return null;
                const fmt = new Intl.DateTimeFormat('en-US', {
                    timeZone: tz,
                    year: 'numeric', month: '2-digit', day: '2-digit',
                    hour: '2-digit', minute: '2-digit', hourCycle: 'h23'
                });
                const parts = {};
                for (const p of fmt.formatToParts(d)) parts[p.type] = p.value;
                return {
                    date: `${parts.year}-${parts.month}-${parts.day}`,
                    minutes: parseInt(parts.hour, 10) * 60 + parseInt(parts.minute, 10)
                };
            } catch(_) { return null; }
        }
        // 判斷批次報價是否「在該市場收盤後 ≥ 5 分鐘」更新過
        function _isQuoteFreshAfterClose(marketKey, clock) {
            const meta = _loadMarketQuoteMeta();
            const m = meta[marketKey];
            if (!m || !m.lastQuoteAt) return false;
            const info = _lastQuoteLocalInfo(marketKey, m.lastQuoteAt);
            if (!info) return false;
            // 必須是同一日（market localDate）且 minutes >= 收盤時間 + 5 分鐘
            if (info.date !== clock.localDate) return false;
            const closeMin = _MARKET_CLOSE_MIN[marketKey];
            return closeMin != null && info.minutes >= closeMin + 5;
        }

        // v15.073：依市場行事曆 + 雙 meta 對齊建立 snapshot
        // 原則：
        //   - target = session.lastCompletedTradingDate（永遠是真交易日，A2 防呆）
        //   - status === 'open' 不 capture
        //   - source = isToday ? 'live-close' : 'backfill'
        //   - fresh_after_close 必要條件：quote meta + analysis meta 兩個 marketDate 都 === target
        //   - backfill 必須兩個 meta 都齊；isToday 退一步可 pending_quote
        //   - A1：snapshot 的 pnl 一律自己重算（isToday 用 prevClose、backfill 用 prevPrevClose），不依賴 stats 內既有的 by-market 累計值
        async function _captureDailyPnlSnapshot(marketKey, stats) {
            try {
                const session = _marketSession(marketKey, new Date());
                if (session.status === 'open') return;

                const target = session.lastCompletedTradingDate;
                if (!target) return;
                if (_isTradingDay(marketKey, target) !== true) return;

                const isToday = (target === session.localDate);
                const source = isToday ? 'live-close' : 'backfill';

                const quoteMeta    = _loadMarketQuoteMeta()[marketKey]    || {};
                const analysisMeta = _loadMarketAnalysisMeta()[marketKey] || {};
                const quoteOk    = quoteMeta.marketDate    === target;
                const analysisOk = analysisMeta.marketDate === target;
                const newStatus = (quoteOk && analysisOk) ? 'fresh_after_close' : 'pending_quote';

                if (!isToday && newStatus !== 'fresh_after_close') return;

                // v15.080：列出該市場所有 active holdings，計算 expected vs withData → complete 旗標
                const _holdings = (stats && stats.holdingsWithStats) || [];
                const marketHoldings = _holdings.filter(h => _holdingMarketKey(h) === marketKey);
                const expectedHoldingsCount = marketHoldings.length;
                if (expectedHoldingsCount === 0) return;

                // v15.082：明確用 close[target] - close[prevTrading] 算「target 那天的當日損益」
                // 不再用 isToday ? h.prevClose : h.prevPrevClose 模糊語意（v15.081 改 baseline 語意後 isToday=true 會誤算 ≈ 0）
                // 來源優先序：baseline.marketDate===target → price_cache → stats fallback
                const prevTrading = _previousTradingDate(marketKey, target);
                let pnlUSD = 0, pnlTWD = 0, withData = 0;
                const missingSymbols = [];
                const usedHoldings = [];
                for (const h of marketHoldings) {
                    let cTarget = null, cPrev = null;
                    // (1) baseline（marketDate guard 過）
                    const bl = _dailyPnlBaselines?.symbols?.[h.symbol];
                    if (bl && bl.marketDate === target) {
                        if (typeof bl.prevClose     === 'number') cTarget = bl.prevClose;
                        if (typeof bl.prevPrevClose === 'number') cPrev   = bl.prevPrevClose;
                    }
                    // (2) price_cache（backfill 抓的近 10 個交易日 close）
                    if ((cTarget == null || cPrev == null) && _dailyPnlPriceCache?.symbols?.[h.symbol]) {
                        const closes = _dailyPnlPriceCache.symbols[h.symbol].closes || [];
                        if (cTarget == null) {
                            const e = closes.find(c => c.marketDate === target);
                            if (e && typeof e.close === 'number') cTarget = e.close;
                        }
                        if (cPrev == null && prevTrading) {
                            const e = closes.find(c => c.marketDate === prevTrading);
                            if (e && typeof e.close === 'number') cPrev = e.close;
                        }
                    }
                    // (3) stats fallback：v15.081 後 h.prevClose = close[target], h.prevPrevClose = close[prevTrading]
                    if (cTarget == null && h.prevClose     != null && h.prevClose     > 0) cTarget = h.prevClose;
                    if (cPrev   == null && h.prevPrevClose != null && h.prevPrevClose > 0) cPrev   = h.prevPrevClose;
                    if (cTarget == null || !(cTarget > 0) || cPrev == null || !(cPrev > 0)) {
                        missingSymbols.push(h.symbol);
                        continue;
                    }
                    const _isHK_HKD = (h.market === 'HK' || (typeof h.symbol === 'string' && h.symbol.endsWith('.HK'))) && !HK_USD_PRICED.has(h.symbol);
                    const dRaw = (cTarget - cPrev) * h.quantity;
                    let dUSD, dTWD;
                    if (_isHK_HKD)            { dUSD = dRaw * exchangeRates.HKD_TWD / exchangeRates.USD_TWD; dTWD = dRaw * exchangeRates.HKD_TWD; }
                    else if (h.market === 'TW') { dUSD = dRaw / exchangeRates.USD_TWD; dTWD = dRaw; }
                    else                       { dUSD = dRaw; dTWD = dRaw * exchangeRates.USD_TWD; }
                    pnlUSD += dUSD; pnlTWD += dTWD; withData++;
                    usedHoldings.push({ symbol: h.symbol, quantity: h.quantity, currentPrice: cTarget, prevClose: cTarget, prevPrevClose: cPrev });
                }
                if (withData === 0) return;

                const complete = (withData === expectedHoldingsCount);

                // v15.080 hotfix P1-1：先把所有 await 跑完再做 read-modify-write，避免三市場並發 capture 互相覆蓋
                let basisUserDataHash = null;
                let basisHoldingsHash = null;
                try { basisUserDataHash = await _userDataHash(_buildLocalUserPayload()); } catch(_) {}
                try { basisHoldingsHash = await _userDataHash({ holdings: _normalizeHoldingsForHash(holdings) }); } catch(_) {}

                // ── 以下 read → decide → write 必須 sync 連續執行 ──
                const snap = _loadDailyPnlSnapshots();
                if (!snap.markets[marketKey]) snap.markets[marketKey] = { current: null, previous: null };
                const slot = snap.markets[marketKey];

                // partial 不可覆蓋 complete；同 target 已有 complete snapshot 時更嚴格
                if (slot.current && slot.current.marketDate === target) {
                    const oldComplete = slot.current.complete !== false;
                    if (oldComplete && !complete) return;
                    const oldStatus = slot.current.quoteStatus || 'fresh_after_close';
                    if (oldStatus === 'fresh_after_close' && newStatus === 'pending_quote') return;
                    if (oldStatus === newStatus && oldComplete === complete) {
                        const oldQA = slot.current.lastQuoteAt;
                        if (oldQA && quoteMeta.lastQuoteAt && new Date(quoteMeta.lastQuoteAt) <= new Date(oldQA)) return;
                    }
                    // v15.082：同 target 已有 complete fresh snapshot 時，新 pnl 與舊 pnl 差異 > 5% 警告
                    // 提早發現 capture 算法回歸（避免 v15.081 那種 baseline 語意改了 capture 沒跟上的 bug）
                    if (oldComplete && complete && oldStatus === 'fresh_after_close' && newStatus === 'fresh_after_close') {
                        const oldPnl = slot.current.pnlTWD || 0;
                        const diff   = Math.abs(pnlTWD - oldPnl);
                        const ref    = Math.max(Math.abs(oldPnl), Math.abs(pnlTWD), 1);
                        if (diff / ref > 0.05) {
                            console.warn(`[DailyPnL] ${marketKey} ${target} complete snapshot pnlTWD changed > 5% (old=${oldPnl.toFixed(0)} new=${pnlTWD.toFixed(0)}) — verify basis correctness`);
                        }
                    }
                } else if (slot.current) {
                    slot.previous = slot.current;
                }

                const newCurrent = {
                    marketKey,
                    marketDate: target,
                    closedAt: new Date().toISOString(),
                    source,
                    pnlUSD, pnlTWD,
                    holdings: usedHoldings,
                    quoteStatus: newStatus,
                    lastQuoteAt: quoteMeta.lastQuoteAt || null,
                    basisField: 'closePair',     // v15.082：明確用 close[target] - close[prevTrading]，不再用 isToday 分支
                    complete,
                    expectedHoldingsCount,
                    withData,
                    missingSymbols,
                    basisUserDataHash,
                    basisHoldingsHash
                };
                if (slot.current && _isSnapshotEquivalent(slot.current, newCurrent)) return;

                slot.current = newCurrent;
                snap.lastCompleteDate = _computeLastCompleteDate(snap.markets);
                _saveDailyPnlSnapshots(snap);
                if (complete && newStatus === 'fresh_after_close') {
                    try { _scheduleSystemSyncPush('daily_pnl_snapshot'); } catch(_) {}
                }
                console.log(`[DailyPnL] Captured ${marketKey} ${newStatus} complete=${complete} (${withData}/${expectedHoldingsCount}) for ${target} src=${source} basis=${slot.current.basisField} (pnlTWD=${pnlTWD.toFixed(0)})`);
            } catch(_) {}
        }
        // v15.076 P0-1：snapshot 等價判斷 — closedAt 不算（每次 new Date() 都會變）
        function _isSnapshotEquivalent(oldS, newS) {
            if (!oldS || !newS) return false;
            if (oldS.marketDate  !== newS.marketDate)  return false;
            if (oldS.quoteStatus !== newS.quoteStatus) return false;
            if (oldS.basisField  !== newS.basisField)  return false;
            if (oldS.source      !== newS.source)      return false;
            // v15.078 hotfix：移除 lastQuoteAt 比較（line 1576-1582 的覆蓋規則已處理「lastQuoteAt 沒推進就 return」，這條比較邏輯上冗餘且導致 silent refresh 推進 quoteMeta.lastQuoteAt 但 pnl 沒變的情境誤判為「不等價」→ 反覆寫入 + mark dirty → 手機 PWA 持續跳「1 筆未同步」）
            const _approxEq = (a, b, tol) => Math.abs((a||0) - (b||0)) < (tol || 0.01);
            if (!_approxEq(oldS.pnlUSD, newS.pnlUSD)) return false;
            if (!_approxEq(oldS.pnlTWD, newS.pnlTWD)) return false;
            const oh = Array.isArray(oldS.holdings) ? oldS.holdings : [];
            const nh = Array.isArray(newS.holdings) ? newS.holdings : [];
            if (oh.length !== nh.length) return false;
            // v15.078 hotfix：holdings 改用容差比較，避免盤後 silent CSV 微小價格差異（小數點 4 位後）反覆觸發 rewrite
            const oMap = new Map(oh.map(h => [h.symbol, h]));
            for (const h of nh) {
                const o = oMap.get(h.symbol);
                if (!o) return false;
                if (!_approxEq(o.quantity,      h.quantity,      0.0001)) return false;
                if (!_approxEq(o.currentPrice,  h.currentPrice,  0.001))  return false;
                if (!_approxEq(o.prevClose,     h.prevClose,     0.001))  return false;
                if (!_approxEq(o.prevPrevClose, h.prevPrevClose, 0.001))  return false;
            }
            return true;
        }

        // ────────────────────────────────────────────────────────
        // v15.071：跨裝置 snapshot merge（三層優先序：fresh > lastQuoteAt > closedAt）
        // ────────────────────────────────────────────────────────
        // v15.080：完整性優先排序 — complete > fresh_after_close > basisUserDataHash 同來源 > lastQuoteAt > closedAt
        function _snapPriority(s, localUserHash) {
            if (!s) return -1;
            const isComplete = s.complete !== false;     // undefined / true → complete（向下相容）
            const isFresh = (s.quoteStatus || 'fresh_after_close') === 'fresh_after_close';
            const sameBasis = !!(localUserHash && s.basisUserDataHash === localUserHash);
            const qt = s.lastQuoteAt ? new Date(s.lastQuoteAt).getTime() : 0;
            const ct = s.closedAt ? new Date(s.closedAt).getTime() : 0;
            // 排序 key（高位優先）：complete > fresh > sameBasis > qt > ct
            return (isComplete ? 1e18 : 0)
                 + (isFresh    ? 1e16 : 0)
                 + (sameBasis  ? 1e14 : 0)
                 + qt
                 + (ct / 1e6);
        }
        function _mergeDailyPnlSnapshots(local, remote, localUserHash) {
            const out = _emptyDailyPnlSnapshots();
            const _MK = ['TW', 'HK', 'US'];
            for (const mk of _MK) {
                const lLocal = (local && local.markets && local.markets[mk]) || { current: null, previous: null };
                const lRemote = (remote && remote.markets && remote.markets[mk]) || { current: null, previous: null };
                // v15.073：丟棄 marketDate 落在週末/已知假日的舊資料
                const candidates = [lLocal.current, lLocal.previous, lRemote.current, lRemote.previous]
                    .filter(s => s && s.marketDate && _isTradingDay(mk, s.marketDate) !== false);
                const byDate = {};
                for (const s of candidates) {
                    if (!byDate[s.marketDate] || _snapPriority(s, localUserHash) > _snapPriority(byDate[s.marketDate], localUserHash)) {
                        byDate[s.marketDate] = s;
                    }
                }
                const dates = Object.keys(byDate).sort();
                const newest = dates.length > 0 ? byDate[dates[dates.length - 1]] : null;
                const prevDate = dates.length > 1 ? dates[dates.length - 2] : null;
                out.markets[mk] = {
                    current: newest || null,
                    previous: prevDate ? byDate[prevDate] : null
                };
            }
            out.lastCompleteDate = _computeLastCompleteDate(out.markets);
            return out;
        }

        function _maybeCaptureDailyPnlSnapshots(stats) {
            if (!stats || !stats.todayPnlByMarket) return;
            for (const mk of ['TW', 'HK', 'US']) {
                _captureDailyPnlSnapshot(mk, stats);
            }
        }

        // #endregion Storage Keys & Freshness Helper

        const PT_FX_CACHE_KEY = 'pt_fx_v1';
        const FX_TTL = 60 * 60 * 1000; // 1 小時

        function _loadFxCache() {
            try {
                const r = JSON.parse(localStorage.getItem(PT_FX_CACHE_KEY) || '{}');
                if (r.ts && r.USD_TWD && r.HKD_TWD && (Date.now() - r.ts < FX_TTL)) return r;
            } catch(_) {}
            return null;
        }
        function _saveFxCache(USD_TWD, HKD_TWD, extra) {
            try { localStorage.setItem(PT_FX_CACHE_KEY, JSON.stringify({ ts: Date.now(), USD_TWD, HKD_TWD, extra: extra || {} })); } catch(_) {}
        }
        function _fxAgeStr(ts) {
            const mins = Math.round((Date.now() - ts) / 60000);
            return mins < 1 ? '剛更新' : mins + ' 分鐘前';
        }
        // 匯率表：顯示幣種（代碼 → { 名稱, 小數位 }）
        const FX_TABLE_CURRENCIES = [
            { code: 'USD', name: '美金',   dec: 2 },
            { code: 'JPY', name: '日圓',   dec: 4 },
            { code: 'KRW', name: '韓元',   dec: 5 },
            { code: 'SGD', name: '新加坡元', dec: 4 },
            { code: 'EUR', name: '歐元',   dec: 3 },
            { code: 'AUD', name: '澳幣',   dec: 3 },
            { code: 'CNY', name: '人民幣',  dec: 3 },
            { code: 'THB', name: '泰銖',   dec: 3 },
            { code: 'VND', name: '越南盾',  dec: 5 },
        ];

        // force=true → 強制打 API；force=false → 快取 1hr 內直接回傳快取值
        async function _fetchFxRates(force) {
            if (!force) {
                const cached = _loadFxCache();
                if (cached) return { USD_TWD: cached.USD_TWD, HKD_TWD: cached.HKD_TWD, extra: cached.extra || {}, fromCache: true, ts: cached.ts };
            }
            try {
                const res = await fetch('https://open.er-api.com/v6/latest/USD', { signal: AbortSignal.timeout(8000) });
                if (!res.ok) return null;
                const data = await res.json();
                const r = data.rates || {};
                const twd = r.TWD, hkd = r.HKD;
                if (!twd || !hkd) return null;
                const USD_TWD = parseFloat(twd.toFixed(4));
                const HKD_TWD = parseFloat((twd / hkd).toFixed(4));
                // 計算各幣種對 TWD 的匯率（1 單位外幣 = ? TWD）
                const extra = {};
                FX_TABLE_CURRENCIES.forEach(({ code }) => {
                    if (r[code]) extra[code] = parseFloat((twd / r[code]).toFixed(6));
                });
                _saveFxCache(USD_TWD, HKD_TWD, extra);
                return { USD_TWD, HKD_TWD, extra, fromCache: false, ts: Date.now() };
            } catch(_) { return null; }
        }

        let tradeType = 'buy';
        let priceReviewData = null;
        let chartInstance = null;
        let _pieSnapshot = null;      // 上次圓餅渲染時的快照
        let _lastPieRenderTime = 0;   // 上次圓餅渲染的時間戳
        let _selectedHoldingSymbol = null;  // 持倉一覽點選鎖定行
        let _selectedAnalysisSymbol = null; // 基本面/技術面點選鎖定行
        let currentDeleteId = null;

        const IMPORT_DATA = { "holdings": [] }; // v13+: 預設空白，自行匯入

        // ==================== 計算統計（強制 100%） ====================
        function calculateStats() {
            let totalCostUSD = 0, totalValueUSD = 0, totalCostTWD = 0, totalValueTWD = 0;
            let totalDayPnLUSD  = 0, totalDayPnLTWD  = 0, hasDayPnL  = false;
            let totalPrevDayPnLUSD = 0, totalPrevDayPnLTWD = 0, hasPrevDayPnL = false;

            // v15.069：今日損益 byMarket（卡片 / strip 用，不受 v15.052 marketOpenedToday 限制）
            const _MARKETS = ['TW', 'HK', 'US'];
            const _now = new Date();
            const todayPnlByMarket = {};
            for (const mk of _MARKETS) {
                const clock = _marketClock(mk, _now);
                todayPnlByMarket[mk] = {
                    status: clock.status, localDate: clock.localDate,
                    lastCompletedTradingDate: clock.lastCompletedTradingDate || null,   // v15.073：UI 顯示「沿用 MM-DD 快照」
                    pnlUSD: 0, pnlTWD: 0,
                    count: 0, withData: 0
                };
            }
            // v15.070：cost / value byMarket（總投入 / 總市值 / 總損益 三張卡片用）
            const holdingsByMarket = {};
            for (const mk of _MARKETS) {
                holdingsByMarket[mk] = { costUSD: 0, costTWD: 0, valueUSD: 0, valueTWD: 0, count: 0 };
            }

            // 第一遍：計算各持倉的 USD/TWD 市值並累加總計
            let holdingsWithStats = holdings.map(h => {
                const costTotal  = h.costPrice * h.quantity;
                const valueTotal = h.currentPrice * h.quantity;
                // 港股但以美金計價的 ETF（掛牌港交所、報價單位為 USD）
                const _isHK_HKD = (h.market === 'HK' || h.symbol.endsWith('.HK')) && !HK_USD_PRICED.has(h.symbol);
                let costUSD = costTotal, valueUSD = valueTotal, costTWD = costTotal, valueTWD = valueTotal;
                if (_isHK_HKD) {
                    costUSD = costTotal * exchangeRates.HKD_TWD / exchangeRates.USD_TWD;
                    valueUSD = valueTotal * exchangeRates.HKD_TWD / exchangeRates.USD_TWD;
                    costTWD = costTotal * exchangeRates.HKD_TWD; valueTWD = valueTotal * exchangeRates.HKD_TWD;
                } else if (h.market === 'TW') {
                    costUSD = costTotal / exchangeRates.USD_TWD; valueUSD = valueTotal / exchangeRates.USD_TWD;
                } else {
                    costTWD = costTotal * exchangeRates.USD_TWD; valueTWD = valueTotal * exchangeRates.USD_TWD;
                }
                totalCostUSD += costUSD; totalValueUSD += valueUSD;
                totalCostTWD += costTWD; totalValueTWD += valueTWD;

                // v15.070：累計到 byMarket（A）
                const _mkA = _holdingMarketKey(h);
                if (holdingsByMarket[_mkA]) {
                    holdingsByMarket[_mkA].costUSD  += costUSD;
                    holdingsByMarket[_mkA].costTWD  += costTWD;
                    holdingsByMarket[_mkA].valueUSD += valueUSD;
                    holdingsByMarket[_mkA].valueTWD += valueTWD;
                    holdingsByMarket[_mkA].count++;
                }

                // 當日損益：從 _prevCloseCache 取昨收價；昨日漲跌：從 _prevPrevCloseCache 取前日收盤
                const prevClose     = window._prevCloseCache?.[h.symbol]     ?? null;
                const prevPrevClose = window._prevPrevCloseCache?.[h.symbol] ?? null;
                let prevDayChangePct = null;
                let prevDayPnlUSD = null, prevDayPnlTWD = null;
                if (prevClose != null && prevClose > 0 && prevPrevClose != null && prevPrevClose > 0) {
                    prevDayChangePct = (prevClose - prevPrevClose) / prevPrevClose * 100;
                    const prevDayPnlNative = (prevClose - prevPrevClose) * h.quantity;
                    if (_isHK_HKD) {
                        prevDayPnlUSD = prevDayPnlNative * exchangeRates.HKD_TWD / exchangeRates.USD_TWD;
                        prevDayPnlTWD = prevDayPnlNative * exchangeRates.HKD_TWD;
                    } else if (h.market === 'TW') {
                        prevDayPnlUSD = prevDayPnlNative / exchangeRates.USD_TWD;
                        prevDayPnlTWD = prevDayPnlNative;
                    } else {
                        prevDayPnlUSD = prevDayPnlNative;
                        prevDayPnlTWD = prevDayPnlNative * exchangeRates.USD_TWD;
                    }
                    totalPrevDayPnLUSD += prevDayPnlUSD;
                    totalPrevDayPnLTWD += prevDayPnlTWD;
                    hasPrevDayPnL = true;
                }
                // 當日損益：若 _marketOpenedToday 明確為 false（槓桿 ETF 今日未開盤）則跳過
                const _mkt = window._marketOpenedToday;
                const marketNotOpened = (_mkt != null && _mkt.hasOwnProperty(h.symbol) && _mkt[h.symbol] === false);
                let dayChangePct = null, dayPnlUSD = null, dayPnlTWD = null;
                if (!marketNotOpened && prevClose != null && prevClose > 0) {
                    const dayChange = h.currentPrice - prevClose;
                    dayChangePct = (dayChange / prevClose) * 100;
                    const dayPnlNative = dayChange * h.quantity;
                    if (_isHK_HKD) {
                        dayPnlUSD = dayPnlNative * exchangeRates.HKD_TWD / exchangeRates.USD_TWD;
                        dayPnlTWD = dayPnlNative * exchangeRates.HKD_TWD;
                    } else if (h.market === 'TW') {
                        dayPnlUSD = dayPnlNative / exchangeRates.USD_TWD;
                        dayPnlTWD = dayPnlNative;
                    } else {
                        dayPnlUSD = dayPnlNative;
                        dayPnlTWD = dayPnlNative * exchangeRates.USD_TWD;
                    }
                    totalDayPnLUSD += dayPnlUSD;
                    totalDayPnLTWD += dayPnlTWD;
                    hasDayPnL = true;
                }

                // v15.069：byMarket 累計（不管 marketNotOpened，卡片用，盤前盤後也算數字；UI 看 status 決定怎麼顯示）
                const _mkKey = _holdingMarketKey(h);
                if (todayPnlByMarket[_mkKey]) {
                    todayPnlByMarket[_mkKey].count++;
                    if (prevClose != null && prevClose > 0) {
                        todayPnlByMarket[_mkKey].withData++;
                        const _dcRaw  = h.currentPrice - prevClose;
                        const _dpRaw  = _dcRaw * h.quantity;
                        let _dpUSD, _dpTWD;
                        if (_isHK_HKD) {
                            _dpUSD = _dpRaw * exchangeRates.HKD_TWD / exchangeRates.USD_TWD;
                            _dpTWD = _dpRaw * exchangeRates.HKD_TWD;
                        } else if (h.market === 'TW') {
                            _dpUSD = _dpRaw / exchangeRates.USD_TWD;
                            _dpTWD = _dpRaw;
                        } else {
                            _dpUSD = _dpRaw;
                            _dpTWD = _dpRaw * exchangeRates.USD_TWD;
                        }
                        todayPnlByMarket[_mkKey].pnlUSD += _dpUSD;
                        todayPnlByMarket[_mkKey].pnlTWD += _dpTWD;
                    }
                }

                return { ...h, costTotalUSD: costUSD, valueTotalUSD: valueUSD,
                    costTotalTWD: costTWD, valueTotalTWD: valueTWD, percentage: 0,
                    prevClose, prevPrevClose,
                    prevDayChangePct, prevDayPnlUSD, prevDayPnlTWD,
                    dayChangePct, dayPnlUSD, dayPnlTWD };
            });

            // 第二遍：計算占比
            if (totalValueUSD > 0)
                holdingsWithStats.forEach(h => { h.percentage = (h.valueTotalUSD / totalValueUSD) * 100; });
            const sumPct = holdingsWithStats.reduce((sum, h) => sum + h.percentage, 0);
            if (sumPct > 0)
                holdingsWithStats.forEach(h => h.percentage = (h.percentage / sumPct) * 100);

            const totalPnLUSD = totalValueUSD - totalCostUSD;
            const totalPnLTWD = totalValueTWD - totalCostTWD;

            // v15.082：今日總計只算「盤中」市場（'open'）；'closed' 已收盤的市場數值已凍進前次收盤損益，不再進今日總額
            // 'not_open' / 'closed_or_holiday' 同樣排除（既有行為）
            const _eligibleTodayStatus = (s) => s === 'open';
            const todayPnlTotal = {
                pnlUSD: _MARKETS.reduce((s, mk) =>
                    _eligibleTodayStatus(todayPnlByMarket[mk].status) ? s + (todayPnlByMarket[mk].pnlUSD || 0) : s, 0),
                pnlTWD: _MARKETS.reduce((s, mk) =>
                    _eligibleTodayStatus(todayPnlByMarket[mk].status) ? s + (todayPnlByMarket[mk].pnlTWD || 0) : s, 0),
                hasAnyData: _MARKETS.some(mk =>
                    _eligibleTodayStatus(todayPnlByMarket[mk].status) && todayPnlByMarket[mk].withData > 0)
            };

            // v15.070 (P1)：昨日損益從 snapshot 讀，依 lastCompleteDate gating，避免日期混搭
            const _snap = _loadDailyPnlSnapshots();
            // v15.074/080：fresh 判定 — fresh_after_close + 真交易日 + complete（v15.080 新增；undefined 為向下相容視為 true）
            const _isFresh = (mk, s) =>
                !!s && !!s.marketDate
                && (s.quoteStatus || 'fresh_after_close') === 'fresh_after_close'
                && _isTradingDay(mk, s.marketDate) !== false   // false=明確假日/週末；true 或 null 都接受
                && s.complete !== false;                        // v15.080：partial 不顯示為昨日損益
            const yesterdayPnlByMarket = {};
            for (const mk of _MARKETS) {
                const slot = (_snap.markets && _snap.markets[mk]) || { current: null, previous: null };
                // v15.074：per-market 各取自己 latest fresh（不再用三市場最舊 lastCompleteDate gating）
                // 從 [current, previous] 篩 fresh 候選，依 marketDate 取最新（避免 current 反而比 previous 舊）
                const candidates = [slot.current, slot.previous]
                    .filter(s => _isFresh(mk, s))
                    .sort((a, b) => b.marketDate.localeCompare(a.marketDate));
                const chosen = candidates[0] || null;
                yesterdayPnlByMarket[mk] = chosen ? {
                    status: 'snapshot',
                    marketDate: chosen.marketDate,
                    closedAt: chosen.closedAt,
                    source: chosen.source || 'live-close',
                    pnlUSD: chosen.pnlUSD || 0,
                    pnlTWD: chosen.pnlTWD || 0,
                    holdingsCount: Array.isArray(chosen.holdings) ? chosen.holdings.length : 0
                } : {
                    status: 'no_snapshot', pnlUSD: null, pnlTWD: null, marketDate: null
                };
            }
            const _lastComplete = _snap.lastCompleteDate || null;
            // v15.074：complete 只看「使用者實際有持倉的市場」— 沒港股的使用者不會永遠 incomplete
            const _activeMarkets = _MARKETS.filter(mk => (holdingsByMarket[mk]?.count || 0) > 0);
            // v15.075：加總範圍與 complete 一致用 _activeMarkets，避免使用者沒持有的市場（如 HK count=0）
            // 仍把歷史 snapshot 算進 headline 總額
            const yesterdayPnlTotal = {
                pnlUSD: _activeMarkets.reduce((s, mk) => s + (yesterdayPnlByMarket[mk].pnlUSD || 0), 0),
                pnlTWD: _activeMarkets.reduce((s, mk) => s + (yesterdayPnlByMarket[mk].pnlTWD || 0), 0),
                complete: _activeMarkets.length > 0
                          && _activeMarkets.every(mk => yesterdayPnlByMarket[mk].status === 'snapshot'),
                hasAny:   _activeMarkets.some(mk => yesterdayPnlByMarket[mk].status === 'snapshot'),
                lastCompleteDate: _lastComplete   // 仍保留供 UI 參考（最舊共同日期，純診斷）
            };

            return {
                totalCost: totalCostUSD, totalValue: totalValueUSD,
                totalPnL: totalPnLUSD, totalPnLPercent: totalCostUSD > 0 ? (totalPnLUSD / totalCostUSD) * 100 : 0,
                totalCostTWD, totalValueTWD, totalPnLTWD,
                totalPnLPercentTWD: totalCostTWD > 0 ? (totalPnLTWD / totalCostTWD) * 100 : 0,
                totalDayPnLUSD, totalDayPnLTWD, hasDayPnL,
                totalPrevDayPnLUSD, totalPrevDayPnLTWD, hasPrevDayPnL,
                // v15.069 新增
                todayPnlByMarket, todayPnlTotal,
                yesterdayPnlByMarket, yesterdayPnlTotal,
                // v15.070 新增（A）
                holdingsByMarket,
                holdingsWithStats
            };
        }

        // ==================== 工具函數 ====================
        let _redoStack = [];

        function _syncUndoRedoBtns() {
            const uc = document.getElementById('undo-count');
            const rc = document.getElementById('redo-count');
            const rb = document.getElementById('redo-btn');
            if (uc) uc.textContent = `(${history.length})`;
            if (rc) rc.textContent = `(${_redoStack.length})`;
            if (rb) { rb.disabled = _redoStack.length === 0; rb.style.opacity = _redoStack.length === 0 ? '0.4' : '1'; }
        }
        function saveHistory() {
            if (history.length >= 50) history.shift();
            history.push(JSON.parse(JSON.stringify(holdings)));
            _redoStack = []; // 新操作清除 redo
            _syncUndoRedoBtns();
        }
        function undoLastAction() {
            if (history.length === 0) return;
            _redoStack.push(JSON.parse(JSON.stringify(holdings)));
            holdings = history.pop();
            _syncUndoRedoBtns();
            _markAndAutoPush(['holdings']);
            renderAll();
        }
        function redoAction() {
            if (_redoStack.length === 0) return;
            history.push(JSON.parse(JSON.stringify(holdings)));
            holdings = _redoStack.pop();
            _syncUndoRedoBtns();
            _markAndAutoPush(['holdings']);
            renderAll();
        }
        function setCurrency(c) {
            currency = c;
            const usdBtn = document.getElementById('currency-usd');
            const twdBtn = document.getElementById('currency-twd');
            if (usdBtn) { usdBtn.style.background = c === 'USD' ? 'rgba(96,165,250,0.25)' : 'rgba(15,30,60,0.5)'; usdBtn.style.fontWeight = c === 'USD' ? '800' : '600'; }
            if (twdBtn) { twdBtn.style.background = c === 'TWD' ? 'rgba(96,165,250,0.25)' : 'rgba(15,30,60,0.5)'; twdBtn.style.fontWeight = c === 'TWD' ? '800' : '600'; }
            renderAll(); // saveToStorage 已在 renderAll 中呼叫
        }
        function setTradeType(type) {
            tradeType = type;
            document.getElementById('buy-btn').style.background = type === 'buy' ? 'linear-gradient(135deg, #10b981 0%, #059669 100%)' : 'rgba(15,30,60,0.6)';
            document.getElementById('buy-btn').style.color = type === 'buy' ? '#060d1a' : '#64748b';
            document.getElementById('sell-btn').style.background = type === 'sell' ? 'linear-gradient(135deg, #ef4444 0%, #dc2626 100%)' : 'rgba(15,30,60,0.6)';
            document.getElementById('sell-btn').style.color = type === 'sell' ? '#fff' : '#64748b';
            document.getElementById('form-qty-label').textContent = type === 'buy' ? '買入股數 *' : '賣出股數 *';
            document.getElementById('form-price-label').textContent = type === 'buy' ? '買入價格 *' : '賣出價格 *';
            document.getElementById('trade-hint').textContent = type === 'buy' ? '買入時若代碼已存在將自動加倉並重算加權平均成本' : '賣出時將從持倉中扣除股數，賣至歸零將移除該持倉';
            const submitBtn = document.getElementById('submit-btn');
            if (submitBtn) {
                submitBtn.textContent = type === 'buy' ? '▲ 確認買入' : '▼ 確認賣出';
                submitBtn.style.background = type === 'buy'
                    ? 'linear-gradient(135deg, #10b981 0%, #059669 100%)'
                    : 'linear-gradient(135deg, #ef4444 0%, #dc2626 100%)';
            }
        }

        // ==================== 渲染 ====================
        // 金額格式化：個位數（不含小數）
        function fmtAmt(val, ccy) {
            const v = Math.round(Math.abs(val));
            return (ccy === 'USD' ? '$' : 'NT$') + v.toLocaleString('en-US');
        }
        function fmtPnl(val, ccy) {
            return (val >= 0 ? '+' : '-') + fmtAmt(val, ccy);
        }

        // ==================== 隱私模式 ====================
        let _privacyMode = false;
        const PT_PRIVACY_KEY = 'pt_privacy_mode';
        const PV_MASK = '<span style="letter-spacing:0.1em;color:#607585;">*****</span>';

        function pv(str) { return _privacyMode ? PV_MASK : str; }

        function togglePrivacy() {
            _privacyMode = !_privacyMode;
            localStorage.setItem(PT_PRIVACY_KEY, _privacyMode ? '1' : '0');
            document.body.classList.toggle('privacy-active', _privacyMode);
            _updatePrivacyBtn();
            renderAll();
            renderRealizedTab();
            renderDepositsTab();
        }
        function _updatePrivacyBtn() {
            const title = _privacyMode ? '隱私模式開啟 — 點擊顯示金額' : '點擊隱藏敏感金額';
            document.querySelectorAll('.pv-toggle-btn').forEach(btn => {
                btn.title = title;
                const slash = btn.querySelector('.pv-slash-icon');
                if (slash) slash.style.display = _privacyMode ? 'block' : 'none';
            });
        }
        function loadPrivacy() {
            _privacyMode = localStorage.getItem(PT_PRIVACY_KEY) === '1';
            document.body.classList.toggle('privacy-active', _privacyMode);
            _updatePrivacyBtn();
        }
        function _pvBtnHtml() {
            const slash = _privacyMode ? 'block' : 'none';
            return `<button onclick="togglePrivacy()" class="pv-toggle-btn" title="${_privacyMode?'隱私模式開啟 — 點擊顯示金額':'點擊隱藏敏感金額'}" style="padding:0.32rem 0.65rem;background:rgba(15,30,60,0.5);border:1px solid rgba(100,116,139,0.3);border-radius:8px;cursor:pointer;display:inline-flex;align-items:center;gap:0.3rem;font-size:0.78rem;color:#f1f5f9;text-transform:none;letter-spacing:0;"><span style="position:relative;display:inline-block;font-size:0.95rem;line-height:1;color:#93c5fd;">◉<span class="pv-slash-icon" style="display:${slash};position:absolute;left:-2px;right:-2px;top:48%;border-top:2.5px solid #f1f5f9;transform:rotate(-30deg);pointer-events:none;"></span></span><span style="font-size:0.75rem;">隱私</span></button>`;
        }

        // ==================== 字型切換 ====================
        // v15.076：字體選項擴充為 4 階循環（預設 → 芫荽 → Noto Sans TC → 霞鶩文楷 TC → 預設）
        const PT_FONT_KEY = 'pt_font';
        const FONT_ORDER = ['default', 'iansui', 'notoSansTc', 'lxgwWenkaiTc'];
        const FONTS = {
            default:      { label: '預設',       family: "'Microsoft JhengHei','微軟正黑體','PingFang TC','Heiti TC',sans-serif" },
            iansui:       { label: '芫荽',       family: "'Iansui','Microsoft JhengHei','PingFang TC',sans-serif",
                            cssUrl: 'https://fonts.googleapis.com/css2?family=Iansui&display=swap' },
            notoSansTc:   { label: 'Noto Sans',  family: "'Noto Sans TC','Microsoft JhengHei','PingFang TC',sans-serif",
                            cssUrl: 'https://fonts.googleapis.com/css2?family=Noto+Sans+TC:wght@400;500;600;700;800;900&display=swap' },
            lxgwWenkaiTc: { label: '霞鶩文楷',   family: "'LXGW WenKai TC','Microsoft JhengHei','PingFang TC',sans-serif",
                            cssUrl: 'https://fonts.googleapis.com/css2?family=LXGW+WenKai+TC:wght@300;400;700&display=swap' }
        };
        let _currentFont = 'default';

        function _ensureFontLink(key) {
            const f = FONTS[key];
            if (!f || !f.cssUrl) return;   // default 用系統字體不需載
            const id = `pt-font-link-${key}`;
            if (document.getElementById(id)) return;
            const link = document.createElement('link');
            link.id   = id;
            link.rel  = 'stylesheet';
            link.href = f.cssUrl;
            document.head.appendChild(link);
        }

        async function applyFont(key) {
            const f = FONTS[key] || FONTS.default;
            if (f.cssUrl) {
                showImportToast('載入字體中…', 1500);
                _ensureFontLink(key);
                try {
                    await Promise.race([
                        document.fonts.ready,
                        new Promise((_, rej) => setTimeout(() => rej(new Error('font-timeout')), 5000))
                    ]);
                    showImportToast(`已套用：${f.label}`, 1200);
                } catch(_) {
                    showImportToast('字體載入逾時，已 fallback 系統字體', 1800);
                    // 不 return，仍讓 family 套上去（CSS fallback 鏈會用後備字體）
                }
            }
            document.body.style.fontFamily = f.family;
            const style = document.getElementById('pt-font-override') || (() => {
                const s = document.createElement('style');
                s.id = 'pt-font-override';
                document.head.appendChild(s);
                return s;
            })();
            style.textContent = key === 'default' ? '' :
                `body,input,select,button,.mono{font-family:${f.family}!important;}`;
            _currentFont = key;
            localStorage.setItem(PT_FONT_KEY, key);
            _updateFontBtn();
        }

        function toggleFont() {
            const idx = FONT_ORDER.indexOf(_currentFont);
            const next = FONT_ORDER[(idx + 1) % FONT_ORDER.length];
            applyFont(next);
        }

        function _updateFontBtn() {
            const btn = document.getElementById('font-toggle-btn');
            const lbl = document.getElementById('font-toggle-label');
            if (!btn) return;
            const f = FONTS[_currentFont] || FONTS.default;
            btn.style.borderColor = 'rgba(100,116,139,0.3)';
            btn.style.color       = '#f1f5f9';
            if (lbl) lbl.textContent = f.label;
        }

        function loadFont() {
            const saved = localStorage.getItem(PT_FONT_KEY) || 'default';
            // 未知 key fallback 到 default
            applyFont(FONTS[saved] ? saved : 'default');
        }

        function renderStats(stats) {
            const grid = document.getElementById('stats-grid');

            // v15.070 (A)：三張卡片（總投入 / 總市值 / 總損益）的市場分項列
            const _hbm = (stats.holdingsByMarket) || {};
            const _kindRow = (mk, label, kind) => {
                const m = _hbm[mk] || { costUSD: 0, costTWD: 0, valueUSD: 0, valueTWD: 0, count: 0 };
                let valStr, col;
                if (m.count === 0) {
                    valStr = '無持倉'; col = '#607585';
                } else if (kind === 'cost') {
                    const v = currency==='USD' ? m.costUSD : m.costTWD;
                    valStr = pv(currency==='USD' ? fmtAmt(v, 'USD') : fmtAmt(v, 'TWD'));
                    col = '#a8bdd0';
                } else if (kind === 'value') {
                    const v = currency==='USD' ? m.valueUSD : m.valueTWD;
                    valStr = pv(currency==='USD' ? fmtAmt(v, 'USD') : fmtAmt(v, 'TWD'));
                    col = '#a8bdd0';
                } else {   // 'pnl'
                    const pnlUSD = m.valueUSD - m.costUSD;
                    const pnlTWD = m.valueTWD - m.costTWD;
                    const v = currency==='USD' ? pnlUSD : pnlTWD;
                    const cBase = currency==='USD' ? m.costUSD : m.costTWD;
                    const pct = cBase > 0 ? (v / cBase * 100).toFixed(2) : null;
                    const pctStr = pct != null ? ` (${v>=0?'+':''}${pct}%)` : '';
                    // v15.076：百分比也包進 pv()，避免反推總投入金額
                    valStr = pv(fmtPnl(v, currency) + pctStr);
                    col = v >= 0 ? '#10b981' : '#ef4444';
                }
                return '<div style="display:flex;justify-content:space-between;align-items:baseline;font-size:0.72rem;line-height:1.5;">'
                    +   '<span style="color:#7e93a6;">' + label + '</span>'
                    +   '<span class="mono" style="color:' + col + ';">' + valStr + '</span>'
                    + '</div>';
            };
            const _byMarketBlock = (kind) =>
                '<div class="stat-card-mkblock">'   // v15.076：CSS class 統一，桌機 separator 對齊
                + _kindRow('TW', '台股', kind)
                + _kindRow('US', '美股', kind)
                + _kindRow('HK', '港股', kind)
                + '</div>';
            // v15.069：今日 / 昨日損益卡片改三行市場拆分；卡片永遠存在（不消失）
            const _statusText = (s) => ({
                'not_open': '今日未開盤',
                'open': '盤中',
                'closed': '已收盤',
                'closed_or_holiday': '假日/休市'
            }[s] || s);

            // ── 昨日損益 卡片（v15.069：讀凍結快照，跨日不浮動）──────
            const prevDayCard = (function() {
                const tot = stats.yesterdayPnlTotal;
                const byMk = stats.yesterdayPnlByMarket;
                const totVal = currency==='USD' ? tot.pnlUSD : tot.pnlTWD;
                const totPos = totVal >= 0;
                // v15.072：headline 只在 complete（三市場都有 snapshot 且 lastCompleteDate 有效）才顯示總額
                // 部分市場 hasAny → 顯示「快照未完整」避免把 US-only 合計誤讀為「昨日損益」
                const totCol = tot.complete ? (totPos ? '#10b981' : '#ef4444') : '#7e93a6';
                // v15.076：只在 complete（真有金額）時套 pv()，狀態文字不遮
                const totStr = tot.complete
                    ? pv(fmtPnl(totVal, currency))
                    : (tot.hasAny ? '快照未完整' : '等待收盤快照');
                const totSubStr = tot.complete
                    ? pv(currency==='USD' ? fmtPnl(tot.pnlTWD, 'TWD') : fmtPnl(tot.pnlUSD, 'USD'))
                    : '';
                const mkRow = (mk, label) => {
                    const m = byMk[mk];
                    if (m.status === 'snapshot') {
                        const v = currency==='USD' ? m.pnlUSD : m.pnlTWD;
                        const pos = v >= 0;
                        const col = pos ? '#10b981' : '#ef4444';
                        // v15.073：marketDate 顯示縮為 MM-DD（年份相同時減少視覺噪音）
                        const dateShort = m.marketDate ? m.marketDate.slice(5) : '';
                        const dateNote = dateShort ? `<span style="margin-left:0.3rem;color:#607585;font-size:0.65rem;">(${dateShort})</span>` : '';
                        return '<div style="display:flex;justify-content:space-between;align-items:baseline;font-size:0.72rem;line-height:1.5;">'
                            +   '<span style="color:#7e93a6;">' + label + dateNote + '</span>'
                            +   '<span class="mono" style="color:' + col + ';">' + pv(fmtPnl(v, currency)) + '</span>'   // v15.076：套 pv()
                            + '</div>';
                    }
                    return '<div style="display:flex;justify-content:space-between;align-items:baseline;font-size:0.72rem;line-height:1.5;">'
                        +   '<span style="color:#7e93a6;">' + label + '<span style="margin-left:0.3rem;color:#607585;font-size:0.65rem;">尚無快照</span></span>'
                        +   '<span class="mono" style="color:#607585;">-</span>'
                        + '</div>';
                };
                return '<div class="stat-card" style="border:1px solid rgba(148,163,184,0.2);">'
                    + '<div class="stat-card-header" style="display:flex;align-items:center;justify-content:space-between;gap:0.5rem;margin-bottom:0.5rem;">'
                    +   '<div style="display:flex;align-items:center;gap:0.6rem;">'
                    +     '<div style="width:36px;height:36px;border-radius:9px;background:linear-gradient(135deg,#3b82f6,#2563eb);display:flex;align-items:center;justify-content:center;color:#fff;font-weight:700;">◁</div>'
                    +     '<div style="display:flex;flex-direction:column;line-height:1.1;">'
                    +       '<span style="color:#60a5fa;font-size:0.85rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;">前次收盤損益</span>'
                    +       '<span style="color:#607585;font-size:0.62rem;letter-spacing:0.5px;">各市場最近收盤</span>'   // v15.073
                    +     '</div>'
                    +   '</div>'
                    + '</div>'
                    + '<div class="mono stat-amount stat-card-amount" style="color:' + totCol + ';">' + totStr + '</div>'
                    + (totSubStr
                        ? '<div class="mono stat-amount-sub stat-card-subamt" style="margin-top:0.3rem;color:' + totCol + ';">' + totSubStr + '</div>'
                        : '<div class="stat-card-subamt" style="visibility:hidden;">&nbsp;</div>')   // v15.076：撐高保 separator 對齊
                    + '<div class="stat-card-mkblock">'
                    +   mkRow('TW', '台股')
                    +   mkRow('US', '美股')
                    +   mkRow('HK', '港股')
                    + '</div>'
                    + '</div>';
            })();

            // ── 今日損益 卡片（v15.069：依 _marketClock 標 status，卡片永遠存在）──
            const dayCard = (function() {
                const tot = stats.todayPnlTotal;
                const byMk = stats.todayPnlByMarket;
                const totVal = currency==='USD' ? tot.pnlUSD : tot.pnlTWD;
                const totPos = totVal >= 0;
                const totCol = tot.hasAnyData ? (totPos ? '#10b981' : '#ef4444') : '#7e93a6';
                const totStr = tot.hasAnyData ? fmtPnl(totVal, currency) : '資料讀取中';
                const totSubStr = tot.hasAnyData
                    ? (currency==='USD' ? fmtPnl(tot.pnlTWD, 'TWD') : fmtPnl(tot.pnlUSD, 'USD'))
                    : '';
                // v15.070 (P3)：未開盤 / 休市時不顯示金額，避免「美股 今日未開盤 +$xxx」自相矛盾
                // v15.073：休市時加註「沿用 MM-DD 快照」對應前交易日
                const mkRow = (mk, label) => {
                    const m = byMk[mk];
                    let valStr, col, isAmount = false;
                    if (m.count === 0) {
                        valStr = '無持倉'; col = '#607585';
                    } else if (m.status === 'not_open') {
                        valStr = '今日未開盤'; col = '#607585';
                    } else if (m.status === 'closed_or_holiday') {
                        const lc = m.lastCompletedTradingDate ? m.lastCompletedTradingDate.slice(5) : '';
                        valStr = lc ? `休市，沿用 ${lc} 快照` : '休市'; col = '#607585';
                    } else if (m.status === 'closed') {
                        // v15.082：已收盤的市場，今日數值已凍進前次收盤損益，不再浮動顯示
                        valStr = '已收盤，見前次收盤'; col = '#607585';
                    } else if (m.withData === 0) {
                        valStr = '資料讀取中'; col = '#607585';
                    } else {
                        const v = currency==='USD' ? m.pnlUSD : m.pnlTWD;
                        valStr = fmtPnl(v, currency);
                        col = v >= 0 ? '#10b981' : '#ef4444';
                        isAmount = true;
                    }
                    return '<div style="display:flex;justify-content:space-between;align-items:baseline;font-size:0.72rem;line-height:1.5;">'
                        +   '<span style="color:#7e93a6;">' + label + '</span>'
                        +   '<span class="mono" style="color:' + col + ';">' + (isAmount ? pv(valStr) : valStr) + '</span>'   // v15.076：金額才套 pv()
                        + '</div>';
                };
                // v15.076：headline / sub 也要 pv()，但只在 hasAnyData（真有金額）才遮，狀態文字不遮
                const totStrFinal = tot.hasAnyData ? pv(totStr) : totStr;
                const totSubFinal = tot.hasAnyData && totSubStr ? pv(totSubStr) : totSubStr;
                return '<div class="stat-card" style="border:1px solid rgba(56,139,253,0.25);">'
                    + '<div class="stat-card-header" style="display:flex;align-items:center;justify-content:space-between;gap:0.5rem;margin-bottom:0.5rem;">'
                    +   '<div style="display:flex;align-items:center;gap:0.6rem;">'
                    +     '<div style="width:36px;height:36px;border-radius:9px;background:linear-gradient(135deg,#3b82f6,#2563eb);display:flex;align-items:center;justify-content:center;color:#fff;font-weight:700;">◈</div>'
                    +     '<span style="color:#60a5fa;font-size:0.85rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;">今日損益</span>'
                    +   '</div>'
                    + '</div>'
                    + '<div class="mono stat-amount stat-card-amount" style="color:' + totCol + ';">' + totStrFinal + '</div>'
                    + (totSubFinal
                        ? '<div class="mono stat-amount-sub stat-card-subamt" style="margin-top:0.3rem;color:' + totCol + ';">' + totSubFinal + '</div>'
                        : '<div class="stat-card-subamt" style="visibility:hidden;">&nbsp;</div>')
                    + '<div class="stat-card-mkblock">'
                    +   mkRow('TW', '台股')
                    +   mkRow('US', '美股')
                    +   mkRow('HK', '港股')
                    + '</div>'
                    + '</div>';
            })();

            grid.innerHTML = `
                <div class="stat-card">
                    <div class="stat-card-header" style="display:flex; align-items:center; gap:0.75rem; margin-bottom:0.75rem;">
                        <div style="width:40px;height:40px;border-radius:10px;background:linear-gradient(135deg,#3b82f6 0%,#2563eb 100%);display:flex;align-items:center;justify-content:center;box-shadow:0 4px 15px rgba(59,130,246,0.4);color:#fff;font-size:1.15rem;font-weight:700;">◆</div>
                        <span style="color:#60a5fa;font-size:0.9rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;">總投入</span>
                    </div>
                    <div class="mono stat-amount stat-card-amount" style="color:#60a5fa;">${pv(currency==='USD' ? fmtAmt(stats.totalCost,'USD') : fmtAmt(stats.totalCostTWD,'TWD'))}</div>
                    <div class="mono stat-amount-sub stat-card-subamt" style="color:#7e93a6;margin-top:0.4rem;">${pv(currency==='USD' ? fmtAmt(stats.totalCostTWD,'TWD') : fmtAmt(stats.totalCost,'USD'))}</div>
                    ${_byMarketBlock('cost')}
                </div>
                <div class="stat-card">
                    <div class="stat-card-header" style="display:flex; align-items:center; gap:0.75rem; margin-bottom:0.75rem;">
                        <div style="width:40px;height:40px;border-radius:10px;background:linear-gradient(135deg,#3b82f6 0%,#2563eb 100%);display:flex;align-items:center;justify-content:center;box-shadow:0 4px 15px rgba(59,130,246,0.4);color:#fff;font-size:1.15rem;font-weight:700;">△</div>
                        <span style="color:#60a5fa;font-size:0.9rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;">總市值</span>
                    </div>
                    <div class="mono stat-amount stat-card-amount" style="color:#3b82f6;">${pv(currency==='USD' ? fmtAmt(stats.totalValue,'USD') : fmtAmt(stats.totalValueTWD,'TWD'))}</div>
                    <div class="mono stat-amount-sub stat-card-subamt" style="color:#7e93a6;margin-top:0.4rem;">${pv(currency==='USD' ? fmtAmt(stats.totalValueTWD,'TWD') : fmtAmt(stats.totalValue,'USD'))}</div>
                    ${_byMarketBlock('value')}
                </div>
                <div class="stat-card">
                    <div class="stat-card-header" style="display:flex;align-items:center;justify-content:space-between;gap:0.5rem;margin-bottom:0.75rem;flex-wrap:nowrap;">
                        <div style="display:flex;align-items:center;gap:0.75rem;">
                            <div style="width:40px;height:40px;border-radius:10px;background:linear-gradient(135deg,#3b82f6 0%,#2563eb 100%);display:flex;align-items:center;justify-content:center;box-shadow:0 4px 15px rgba(59,130,246,0.4);"><span style="color:#fff;font-size:1.15rem;font-weight:700;">${stats.totalPnL>=0?'△':'▽'}</span></div>
                            <span style="color:#60a5fa;font-size:0.9rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;">總損益</span>
                        </div>
                        <span class="mono stat-pct ${stats.totalPnL>=0?'profit':'loss'}" style="flex-shrink:0;">${pv('('+(stats.totalPnL>=0?'+':'')+stats.totalPnLPercent.toFixed(2)+'%)')}</span>
                    </div>
                    <div class="mono stat-amount stat-card-amount ${stats.totalPnL>=0?'profit':'loss'}">${pv(currency==='USD' ? fmtPnl(stats.totalPnL,'USD') : fmtPnl(stats.totalPnLTWD,'TWD'))}</div>
                    <div class="mono stat-amount-sub stat-card-subamt" style="margin-top:0.45rem;">
                        <span class="${stats.totalPnLTWD>=0?'profit':'loss'}">${pv(currency==='USD' ? fmtPnl(stats.totalPnLTWD,'TWD') : fmtPnl(stats.totalPnL,'USD'))}</span>
                    </div>
                    ${_byMarketBlock('pnl')}
                </div>
                ${prevDayCard}
                ${dayCard}
            `;
        }

        // ──────────────────────────────────────────────────────────
        // v15.066：持倉一覽 tbody 差異更新（取代每分鐘自動更新時整表 innerHTML 重建）
        // 目的：保留滾動位置 + click 鎖定（hrow-selected）+ hover 狀態；降低 CPU
        // 邏輯：每個 row 由 (symbol -> fingerprint) cache 控管；fp 含 i 解決奇偶背景
        // ──────────────────────────────────────────────────────────
        let _holdingRowCache = {};   // { [symbol]: fingerprint }

        function _holdingRowFingerprint(h, i, currency) {
            return [
                h.symbol, h.market, h.name || '',
                h.quantity, h.costPrice, h.currentPrice,
                h.costTotalUSD, h.costTotalTWD,
                h.valueTotalUSD, h.valueTotalTWD,
                h.prevDayChangePct, h.dayChangePct,
                h.dayPnlUSD, h.dayPnlTWD,
                h.prevDayPnlUSD, h.prevDayPnlTWD,
                currency, i
            ].join('|');
        }

        function _buildHoldingRowHTML(h, i, currency) {
            const pnl    = h.valueTotalUSD - h.costTotalUSD;
            const pnlTWD = h.valueTotalTWD - h.costTotalTWD;
            const isProfit = pnl >= 0;
            const pnlPct = currency==='USD'
                ? (h.costTotalUSD  > 0 ? (pnl    / h.costTotalUSD  * 100).toFixed(2) : '0.00')
                : (h.costTotalTWD  > 0 ? (pnlTWD / h.costTotalTWD  * 100).toFixed(2) : '0.00');
            const priceCcy = (h.market==='HK'||h.symbol.endsWith('.HK')) && !HK_USD_PRICED.has(h.symbol) ? 'HK$' : h.market==='TW' ? 'NT$' : '$';
            const displayValue = currency==='USD' ? fmtAmt(h.valueTotalUSD,'USD') : fmtAmt(h.valueTotalTWD,'TWD');
            const displayPnl   = currency==='USD' ? fmtPnl(pnl,'USD') : fmtPnl(pnlTWD,'TWD');
            const bg = i%2===0 ? 'rgba(15,30,60,0.3)' : 'rgba(10,20,40,0.2)';

            let prevDayChgCell = '<td style="padding:0.55rem 0.75rem;text-align:right;color:#7e93a6;">-</td>';
            if (h.prevDayChangePct != null) {
                const pp = h.prevDayChangePct >= 0;
                prevDayChgCell = '<td style="padding:0.55rem 0.75rem;text-align:right;">'
                    + '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:'+(pp?'rgba(16,185,129,0.12)':'rgba(239,68,68,0.12)')+';color:'+(pp?'#6ee7b7':'#fca5a5')+';font-size:0.88rem;">'
                    + (pp?'+':'') + h.prevDayChangePct.toFixed(2) + '%</span></td>';
            }
            let dayChgCell = '<td style="padding:0.55rem 0.75rem;text-align:right;color:#7e93a6;">-</td>';
            let dayPnlCell = '<td style="padding:0.55rem 0.75rem;text-align:right;color:#7e93a6;">-</td>';
            if (h.dayChangePct != null) {
                const cp = h.dayChangePct >= 0;
                dayChgCell = '<td style="padding:0.55rem 0.75rem;text-align:right;">'
                    + '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:'+(cp?'rgba(16,185,129,0.15)':'rgba(239,68,68,0.15)')+';color:'+(cp?'#10b981':'#ef4444')+';font-weight:600;">'
                    + (cp?'+':'') + h.dayChangePct.toFixed(2) + '%</span></td>';
                const dp    = currency==='USD' ? h.dayPnlUSD : h.dayPnlTWD;
                const dpp   = dp >= 0;
                const dpStr = fmtPnl(dp, currency);
                dayPnlCell = '<td style="padding:0.55rem 0.75rem;text-align:right;color:'+(dpp?'#10b981':'#ef4444')+';">'+dpStr+'</td>';
            }

            return `<tr data-symbol="${h.symbol}" style="background:${bg};">
                <td style="padding:0.55rem 0.75rem;font-weight:600;white-space:nowrap;"><button onclick="event.stopPropagation();_fillTradeForm('${h.symbol.replace(/'/g, "\\'")}','${h.market}')" style="padding:2px 7px;margin-right:6px;min-width:30px;min-height:28px;background:rgba(96,165,250,0.15);border:1px solid rgba(96,165,250,0.35);border-radius:5px;color:#60a5fa;font-size:0.95rem;cursor:pointer;vertical-align:middle;line-height:1;">${h.market==='TW'?'🇹🇼':h.market==='HK'?'🇭🇰':'🇺🇸'}</button>${h.symbol}<br><small style="color:#7e93a6;font-weight:400;">${h.name||''}</small></td>
                <td style="padding:0.55rem 0.75rem;text-align:right;">${h.quantity.toLocaleString('en-US',{maximumFractionDigits:4})}</td>
                <td style="padding:0.55rem 0.75rem;text-align:right;color:#a8bdd0;">${priceCcy}${h.costPrice.toLocaleString('en-US',{minimumFractionDigits:2})}</td>
                <td style="padding:0.55rem 0.75rem;text-align:right;color:#60a5fa;">${priceCcy}${h.currentPrice.toLocaleString('en-US',{minimumFractionDigits:2})}</td>
                ${prevDayChgCell}
                ${dayChgCell}
                ${dayPnlCell}
                <td style="padding:0.55rem 0.75rem;text-align:right;">${displayValue}</td>
                <td style="padding:0.55rem 0.75rem;text-align:right;color:${isProfit?'#10b981':'#ef4444'};">${displayPnl}</td>
                <td style="padding:0.55rem 0.75rem;text-align:right;color:${isProfit?'#10b981':'#ef4444'};"><span style="padding:0.2rem 0.5rem;border-radius:6px;background:${isProfit?'rgba(16,185,129,0.15)':'rgba(239,68,68,0.15)'};">${isProfit?'+':''}${pnlPct}%</span></td>
            </tr>`;
        }

        function _patchHoldingTableBody(tbody, sorted, currency) {
            const newSymbols = new Set(sorted.map(h => h.symbol));
            // 1. 移除已不存在的 symbol
            Array.from(tbody.querySelectorAll('tr[data-symbol]')).forEach(tr => {
                const sym = tr.dataset.symbol;
                if (!newSymbols.has(sym)) {
                    tr.remove();
                    delete _holdingRowCache[sym];
                }
            });
            // 2. 依排序順序遍歷：先處理新增 / 替換內容；位置校正在最後統一做（避免 replaceWith 後留在舊 index）
            sorted.forEach((h, i) => {
                const fp = _holdingRowFingerprint(h, i, currency);
                const existing = tbody.querySelector('tr[data-symbol="' + CSS.escape(h.symbol) + '"]');
                if (!existing) {
                    const tmp = document.createElement('tbody');
                    tmp.innerHTML = _buildHoldingRowHTML(h, i, currency);
                    const newRow = tmp.firstElementChild;
                    const ref = tbody.children[i] || null;
                    tbody.insertBefore(newRow, ref);
                    _holdingRowCache[h.symbol] = fp;
                } else if (_holdingRowCache[h.symbol] !== fp) {
                    // 內容變更：replaceWith 會讓新 row 接收舊 row 的位置；位置校正交給下一個 if 處理
                    const tmp = document.createElement('tbody');
                    tmp.innerHTML = _buildHoldingRowHTML(h, i, currency);
                    existing.replaceWith(tmp.firstElementChild);
                    _holdingRowCache[h.symbol] = fp;
                }
                // v15.067 修正（Codex review）：每輪都做位置校正，不只 fp-same 分支
                // 不論是新建、replace 還是 move，都確認 row 在正確 index
                const currentRow = tbody.querySelector('tr[data-symbol="' + CSS.escape(h.symbol) + '"]');
                const ref = tbody.children[i];
                if (currentRow && ref && ref !== currentRow) {
                    tbody.insertBefore(currentRow, ref);
                }
            });
        }

        function renderTable(stats) {
            // v15.067：null 值排到最後（不論 asc/desc）；null/undefined 一律視為「最差」
            const _nullToBottom = (v, dir) => {
                if (v == null || isNaN(v)) return dir === 'asc' ? Infinity : -Infinity;
                return v;
            };
            const sorted = [...stats.holdingsWithStats].sort((a, b) => {
                let va, vb;
                if (_tableSort.by === 'symbol') {
                    va = a.symbol; vb = b.symbol;
                    return _tableSort.dir === 'asc' ? va.localeCompare(vb) : vb.localeCompare(va);
                } else if (_tableSort.by === 'pnl') {
                    va = a.valueTotalUSD - a.costTotalUSD;
                    vb = b.valueTotalUSD - b.costTotalUSD;
                } else if (_tableSort.by === 'pnlpct') {
                    va = a.costTotalUSD > 0 ? (a.valueTotalUSD - a.costTotalUSD) / a.costTotalUSD : 0;
                    vb = b.costTotalUSD > 0 ? (b.valueTotalUSD - b.costTotalUSD) / b.costTotalUSD : 0;
                } else if (_tableSort.by === 'prevDayPct') {
                    // v15.067：昨日漲跌幅排序
                    va = _nullToBottom(a.prevDayChangePct, _tableSort.dir);
                    vb = _nullToBottom(b.prevDayChangePct, _tableSort.dir);
                } else if (_tableSort.by === 'dayPct') {
                    // v15.067：今日漲跌幅排序
                    va = _nullToBottom(a.dayChangePct, _tableSort.dir);
                    vb = _nullToBottom(b.dayChangePct, _tableSort.dir);
                } else if (_tableSort.by === 'dayPnl') {
                    // v15.067：今日損益排序（依目前幣別）
                    const fa = currency === 'USD' ? a.dayPnlUSD : a.dayPnlTWD;
                    const fb = currency === 'USD' ? b.dayPnlUSD : b.dayPnlTWD;
                    va = _nullToBottom(fa, _tableSort.dir);
                    vb = _nullToBottom(fb, _tableSort.dir);
                } else { // value (default)
                    va = a.valueTotalUSD; vb = b.valueTotalUSD;
                }
                return _tableSort.dir === 'asc' ? va - vb : vb - va;
            });
            const si = (col) => _tableSort.by === col ? (_tableSort.dir === 'desc' ? ' ▼' : ' ▲') : '';
            const thBtn = (col, label, align='right') =>
                `<th onclick="setTableSort('${col}')" style="padding:0.6rem 0.75rem;text-align:${align};color:#60a5fa;cursor:pointer;user-select:none;white-space:nowrap;">${label}${si(col)}</th>`;
            // v15.066：tbody 由 _patchHoldingTableBody 處理（DOM diff），不再 join 字串

            const dayPnlFooter = stats.hasDayPnL ? (() => {
                const dp  = currency==='USD' ? stats.totalDayPnLUSD : stats.totalDayPnLTWD;
                const pos = dp >= 0;
                const dpStr = fmtPnl(dp, currency);
                return '<td></td>'   // 昨日漲跌（合計列空白）
                    + '<td style="padding:0.65rem 0.75rem;text-align:right;color:'+(pos?'#10b981':'#ef4444')+';font-weight:700;"></td>'
                    + '<td style="padding:0.65rem 0.75rem;text-align:right;color:'+(pos?'#10b981':'#ef4444')+';font-weight:700;">'+dpStr+'</td>';
            })() : '<td></td><td></td><td></td>';

            // v15.066：thead / tfoot 各自重建，tbody 用 DOM diff（保留滾動位置 + click 鎖定）
            const table = document.getElementById('holdings-table');
            // 確保 thead / tbody / tfoot 都存在（首次渲染）
            if (!table.tHead)         table.appendChild(document.createElement('thead'));
            if (!table.tBodies[0])    table.appendChild(document.createElement('tbody'));
            if (!table.tFoot)         table.appendChild(document.createElement('tfoot'));

            // thead 重建（含 sort indicator，每輪變化）
            // v15.067：昨日漲跌 / 今日漲跌 / 今日損益 改為可排序
            table.tHead.innerHTML = `<tr>
                ${thBtn('symbol','代碼','left')}
                <th style="padding:0.6rem 0.75rem;text-align:right;color:#60a5fa;">持有股數</th>
                <th style="padding:0.6rem 0.75rem;text-align:right;color:#60a5fa;">成本價</th>
                <th style="padding:0.6rem 0.75rem;text-align:right;color:#60a5fa;">現價</th>
                ${thBtn('prevDayPct','昨日漲跌')}
                ${thBtn('dayPct','今日漲跌')}
                ${thBtn('dayPnl','今日損益')}
                ${thBtn('value','市值 ('+currency+')')}
                ${thBtn('pnl','總損益 ('+currency+')')}
                ${thBtn('pnlpct','總損益%')}
            </tr>`;

            // tbody 差異更新（保留 hover / click 鎖定 / 滾動位置）
            _patchHoldingTableBody(table.tBodies[0], sorted, currency);

            // tfoot 重建（合計列）
            table.tFoot.innerHTML = `<tr style="background:rgba(30,58,110,0.2);">
                <td style="padding:0.65rem 0.75rem;color:#60a5fa;font-weight:700;">合計</td>
                <td></td><td></td><td></td>
                ${dayPnlFooter}
                <td style="padding:0.65rem 0.75rem;text-align:right;color:#60a5fa;font-weight:700;">${currency==='USD'?fmtAmt(stats.totalValue,'USD'):fmtAmt(stats.totalValueTWD,'TWD')}</td>
                <td style="padding:0.65rem 0.75rem;text-align:right;color:${stats.totalPnL>=0?'#10b981':'#ef4444'};font-weight:700;">${currency==='USD'?fmtPnl(stats.totalPnL,'USD'):fmtPnl(stats.totalPnLTWD,'TWD')}</td>
                <td style="padding:0.65rem 0.75rem;text-align:right;color:${stats.totalPnL>=0?'#10b981':'#ef4444'};font-weight:700;">${stats.totalPnL>=0?'+':''}${stats.totalPnLPercent.toFixed(2)}%</td>
            </tr>`;

            _applyHoldingRowSelection();
        }

        function _applyHoldingRowSelection() {
            document.querySelectorAll('#holdings-table tbody tr').forEach(r => {
                r.classList.toggle('hrow-selected', r.dataset.symbol === _selectedHoldingSymbol);
            });
        }

        function _applyAnalysisRowSelection() {
            ['#tab-pane-2 table tbody tr', '#tab-pane-3 table tbody tr'].forEach(sel => {
                document.querySelectorAll(sel).forEach(r => {
                    r.classList.toggle('hrow-selected', r.dataset.symbol === _selectedAnalysisSymbol);
                });
            });
        }

        // ── v15.022 差異更新輔助 ──
        function _cardFingerprint(h) {
            // 把所有會影響卡片顯示的欄位壓成一個字串
            return [
                h.symbol, h.market, h.name||'', h.persist?1:0,
                h.quantity, h.costPrice, h.currentPrice,
                h.percentage?.toFixed(4)||0,
                h.valueTotalUSD?.toFixed(4)||0, h.costTotalUSD?.toFixed(4)||0,
                h.dayChangePct??'', h.dayPnlUSD?.toFixed(4)||0, h.dayPnlTWD?.toFixed(4)||0,
                h.lots?.length||0,
                currency
            ].join('|');
        }

        function _buildCardHTML(h, i, isExpanded) {
            const pnl = h.valueTotalUSD - h.costTotalUSD;
            const isProfit = pnl >= 0;
            const priceCcy = (h.market==='HK'||h.symbol.endsWith('.HK')) && !HK_USD_PRICED.has(h.symbol) ? 'HK$' : h.market==='TW' ? 'NT$' : '$';
            const pnlPct = h.costTotalUSD > 0 ? pnl/h.costTotalUSD*100 : 0;
            const dayInfo = (function() {
                if (h.dayChangePct == null) return null;
                const cp = h.dayChangePct >= 0;
                const col = cp ? '#10b981' : '#ef4444';
                const bgc = cp ? 'rgba(16,185,129,0.12)' : 'rgba(239,68,68,0.12)';
                const dp = currency==='USD' ? h.dayPnlUSD : h.dayPnlTWD;
                const dpStr = currency==='USD'
                    ? (dp>=0?'+':'-')+'$'+Math.abs(dp).toLocaleString('en-US',{minimumFractionDigits:2})
                    : (dp>=0?'+':'-')+'NT$'+Math.abs(Math.round(dp)).toLocaleString('en-US');
                return { cp, col, bgc, dpStr };
            })();
            return `
            <div class="holding-row" id="hcard-${h.id}" style="animation-delay:${i*0.05}s; border-left-color:${h.persist ? '#10b981' : '#3b82f6'};">
                <div class="holding-header" onclick="toggleHolding(${h.id})">
                    <div style="display:flex; align-items:center; gap:0.5rem; flex-wrap:wrap; flex:1;">
                        <span class="market-badge">${h.market==='TW'?'🇹🇼':h.market==='HK'?'🇭🇰':'🇺🇸'} ${h.market}</span>
                        <span class="mono" style="color:#f1f5f9;font-size:1rem;font-weight:600;">${h.symbol}</span>
                        <span style="padding:0.2rem 0.4rem;background:rgba(59,130,246,0.15);border:1px solid rgba(59,130,246,0.3);border-radius:4px;font-size:0.72rem;font-weight:600;color:#60a5fa;">${h.percentage.toFixed(2)}%</span>
                        ${h.name ? '<span style="color:#a8bdd0;font-size:0.8rem;">'+h.name+'</span>' : ''}
                    </div>
                    <div style="display:flex; align-items:center; gap:0.6rem; flex-shrink:0;">
                        <span class="mono" style="font-size:0.88rem;font-weight:600;color:${isProfit?'#10b981':'#ef4444'};">${isProfit?'+':''}${pnlPct.toFixed(2)}%</span>
                        ${dayInfo ? '<span class="mono" style="font-size:0.82rem;color:'+dayInfo.col+';">'+dayInfo.dpStr+'</span>' : ''}
                        <span id="holding-chevron-${h.id}" style="color:#7e93a6;font-size:0.8rem;margin-left:0.25rem;">${isExpanded?'▲':'▶'}</span>
                    </div>
                </div>
                <div class="holding-body" id="holding-body-${h.id}" style="display:${isExpanded?'block':'none'};">
                    <div style="display:flex; justify-content:space-between; align-items:flex-start; flex-wrap:wrap; gap:1rem;">
                        <div style="flex:1; min-width:200px;">
                            <label title="打勾後下次開啟網頁此持倉仍保留" style="display:inline-flex;align-items:center;gap:0.4rem;cursor:pointer;user-select:none;padding:0.25rem 0.6rem;background:${h.persist ? 'rgba(16,185,129,0.12)' : 'rgba(100,116,139,0.1)'};border:1px solid ${h.persist ? 'rgba(16,185,129,0.4)' : 'rgba(100,116,139,0.25)'};border-radius:6px;">
                                <input type="checkbox" ${h.persist ? 'checked' : ''} onchange="togglePersist(${h.id}, this.checked)" style="width:16px;height:16px;accent-color:#10b981;cursor:pointer;">
                                <span style="font-size:0.8rem;font-weight:600;color:${h.persist ? '#10b981' : '#64748b'};">${h.persist ? '✓ 下次保留' : '下次不保留'}</span>
                            </label>
                            <div style="display:flex; align-items:center; gap:0.5rem; margin-top:0.4rem;">
                                <span style="color:#7e93a6;font-size:0.85rem;">持有</span>
                                <input type="number" step="0.01" value="${h.quantity}" onchange="updateQuantity(${h.id}, this.value)" style="width:100px;padding:0.25rem 0.5rem;font-size:0.85rem;background:rgba(16,185,129,0.05);border:1px solid rgba(16,185,129,0.2);border-radius:4px;color:#e2e8f0;">
                                <span style="color:#7e93a6;font-size:0.85rem;">股</span>
                            </div>
                        </div>
                        <div style="flex:1; min-width:250px;">
                            <div style="display:grid; grid-template-columns:1fr 1fr; gap:0.75rem; font-size:0.9rem;">
                                <div><div style="color:#a8bdd0;margin-bottom:0.25rem;">成本價</div><input type="number" step="0.01" value="${h.costPrice}" onchange="updateCostPrice(${h.id}, this.value)" style="width:120px;padding:0.5rem;font-size:0.9rem;background:rgba(16,185,129,0.05);border:1px solid rgba(16,185,129,0.2);border-radius:6px;color:#e2e8f0;"></div>
                                <div><div style="color:#a8bdd0;margin-bottom:0.25rem;">現價</div><input type="number" step="0.01" value="${h.currentPrice}" onchange="updateCurrentPrice(${h.id}, this.value)" style="width:120px;padding:0.5rem;font-size:0.9rem;background:rgba(59,130,246,0.05);border:1px solid rgba(59,130,246,0.2);border-radius:6px;color:#e2e8f0;"></div>
                                <div><div style="color:#a8bdd0;margin-bottom:0.25rem;">成本總額</div><div class="mono">${priceCcy}${h.costTotalUSD.toLocaleString('en-US',{minimumFractionDigits:2})}</div></div>
                                <div><div style="color:#a8bdd0;margin-bottom:0.25rem;">市值</div><div class="mono">${priceCcy}${h.valueTotalUSD.toLocaleString('en-US',{minimumFractionDigits:2})}</div></div>
                            </div>
                        </div>
                        <div style="display:flex; align-items:center; gap:1rem;">
                            <div style="text-align:right;">
                                <div style="color:#7e93a6;font-size:0.78rem;margin-bottom:0.15rem;">總損益</div>
                                <div class="mono" style="font-size:1.1rem;font-weight:600;"><span class="${isProfit?'profit':'loss'}">${isProfit?'+':'-'}${priceCcy}${Math.abs(pnl).toLocaleString('en-US',{minimumFractionDigits:2})}</span></div>
                                <div class="mono" style="font-size:0.95rem;margin-top:0.15rem;"><span class="${isProfit?'profit':'loss'}">${isProfit?'+':''}${pnlPct.toFixed(2)}%</span></div>
                                ${dayInfo ? '<div style="margin-top:0.4rem;padding-top:0.35rem;border-top:1px solid rgba(255,255,255,0.08);">'
                                    + '<div style="color:#7e93a6;font-size:0.78rem;margin-bottom:0.15rem;">今日損益</div>'
                                    + '<div class="mono" style="font-size:0.9rem;color:'+dayInfo.col+';">'
                                    + '<span style="padding:0.15rem 0.4rem;border-radius:4px;background:'+dayInfo.bgc+';">'+(dayInfo.cp?'+':'')+h.dayChangePct.toFixed(2)+'%</span>'
                                    + '&nbsp;'+dayInfo.dpStr+'</div></div>' : ''}
                            </div>
                            <button onclick="deleteHolding(${h.id})" class="btn-delete" title="刪除">×</button>
                        </div>
                    </div>
                </div>
                ${(h.lots && h.lots.length > 0) ? `
                <div style="margin:0.5rem 0.75rem 0.65rem 1rem; padding-top:0.6rem; border-top:1px solid rgba(255,255,255,0.07);">
                    <div style="color:#7e93a6; font-size:0.72rem; font-weight:600; letter-spacing:0.04em; margin-bottom:0.35rem;">成本批次（FIFO 順序）</div>
                    ${h.lots.map((lot, li) => {
                        const d  = new Date(lot.date);
                        const ds = isNaN(d) ? '' : d.toLocaleDateString('zh-TW',{year:'numeric',month:'2-digit',day:'2-digit'});
                        const lotTotal = (lot.qty * lot.cost).toLocaleString('en-US',{minimumFractionDigits:2,maximumFractionDigits:2});
                        return `<div style="display:flex;gap:0.65rem;align-items:center;font-size:0.77rem;padding:0.18rem 0;border-bottom:1px solid rgba(255,255,255,0.04);">
                            <span style="color:#607585;min-width:78px;">${ds}</span>
                            <span style="color:#e2e8f0;">${parseFloat(lot.qty.toFixed(4)).toLocaleString('en-US',{maximumFractionDigits:4})} 股</span>
                            <span style="color:#7e93a6;">@</span>
                            <span style="color:#60a5fa;">${priceCcy}${parseFloat(lot.cost.toFixed(4))}</span>
                            <span style="color:#607585;margin-left:auto;">成本 ${priceCcy}${lotTotal}</span>
                        </div>`;
                    }).join('')}
                </div>` : ''}
            </div>`;
        }

        function renderHoldingsDetail(stats) {
            const container = document.getElementById('holdings-list');
            const sorted = stats.holdingsWithStats.sort((a,b) => b.valueTotalUSD - a.valueTotalUSD);
            const newIds = new Set(sorted.map(h => h.id));

            // 移除已不存在的卡片
            Object.keys(_cardCache).forEach(id => {
                if (!newIds.has(Number(id))) {
                    const el = document.getElementById('hcard-' + id);
                    if (el) el.remove();
                    delete _cardCache[id];
                    delete _cardExpanded[id];
                }
            });

            // 新增或更新卡片（依排序順序插入/移動）
            sorted.forEach((h, i) => {
                const fp = _cardFingerprint(h);
                const existing = document.getElementById('hcard-' + h.id);
                const isExpanded = _cardExpanded[h.id] ?? _allExpanded;

                if (!existing) {
                    // 新卡片：建立並插入到正確位置
                    _cardExpanded[h.id] = isExpanded;
                    const tmp = document.createElement('div');
                    tmp.innerHTML = _buildCardHTML(h, i, isExpanded).trim();
                    const newEl = tmp.firstChild;
                    const ref = container.children[i] || null;
                    container.insertBefore(newEl, ref);
                    _cardCache[h.id] = fp;
                } else {
                    // 已存在：檢查是否需要更新內容
                    if (_cardCache[h.id] !== fp) {
                        const expanded = document.getElementById('holding-body-' + h.id)?.style.display !== 'none';
                        _cardExpanded[h.id] = expanded;
                        const tmp = document.createElement('div');
                        tmp.innerHTML = _buildCardHTML(h, i, expanded).trim();
                        existing.replaceWith(tmp.firstChild);
                        _cardCache[h.id] = fp;
                    }
                    // 確保順序正確（排序改變時移動卡片）
                    const ref = container.children[i];
                    if (ref && ref.id !== 'hcard-' + h.id) {
                        container.insertBefore(document.getElementById('hcard-' + h.id), ref);
                    }
                }
            });

            document.getElementById('holdings-count').textContent = holdings.length;
            syncPersistAllCheckbox();
        }

        function _shouldRenderPie(stats) {
            // 首次渲染
            if (!_pieSnapshot) return true;
            // 每 30 分鐘強制更新
            if (Date.now() - _lastPieRenderTime > 30 * 60 * 1000) return true;
            // 持倉數量變化
            if (stats.holdingsWithStats.length !== _pieSnapshot.count) return true;
            // 幣別切換
            if (currency !== _pieSnapshot.currency) return true;
            // 隱私模式切換
            if (_privacyMode !== _pieSnapshot.privacyMode) return true;
            // v15.076 P0-2：cashNow 改用 _depositsTWD()（跟 renderPie 一致；v15.049 改存款 Tab 後 #cash-twd-input 已非真實來源）
            const cashNow    = _depositsTWD();
            const cryptoNow  = parseFloat(document.getElementById('crypto-twd-input')?.value) || 0;
            const moxaNow    = parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0;
            const cbCash     = document.getElementById('cash-pie-cb')?.checked   ?? false;
            const cbCrypto   = document.getElementById('crypto-pie-cb')?.checked ?? false;
            const cbMoxa     = document.getElementById('moxa-pie-cb')?.checked   ?? false;
            if (cashNow   !== _pieSnapshot.cash   || cryptoNow !== _pieSnapshot.crypto ||
                moxaNow   !== _pieSnapshot.moxa   || cbCash    !== _pieSnapshot.cbCash ||
                cbCrypto  !== _pieSnapshot.cbCrypto || cbMoxa  !== _pieSnapshot.cbMoxa) return true;
            // 任何持倉佔總資產比例變化超過 0.5%
            const effectiveCash   = cbCash   ? cashNow   : 0;
            const effectiveCrypto = cbCrypto ? cryptoNow : 0;
            const effectiveMoxa   = cbMoxa   ? moxaNow   : 0;
            const grandTotal = stats.totalValueTWD + effectiveCash + effectiveCrypto + effectiveMoxa;
            if (grandTotal <= 0) return true;
            for (const h of stats.holdingsWithStats) {
                // v15.076 P0-2：欄位名修正 valueTWD → valueTotalTWD（holdingsWithStats 實際 return 欄位）
                const ratio = h.valueTotalTWD / grandTotal;
                const prev  = _pieSnapshot.ratios[h.id];
                if (prev == null) return true;
                if (Math.abs(ratio - prev) > 0.005) return true; // 佔比差距超過 0.5%
            }
            return false;
        }

        function renderPie(stats) {
            const pieSection    = document.getElementById('pie-section');
            const cashTWD       = _depositsTWD();
            const cryptoTWD     = parseFloat(document.getElementById('crypto-twd-input')?.value) || 0;
            const moxaTWD       = parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0;
            const showCashInPie   = document.getElementById('cash-pie-cb')?.checked   ?? false;
            const showCryptoInPie = document.getElementById('crypto-pie-cb')?.checked ?? false;
            const showMoxaInPie   = document.getElementById('moxa-pie-cb')?.checked   ?? false;
            const hasAny = holdings.length > 0 || cashTWD > 0 || cryptoTWD > 0 || moxaTWD > 0;
            pieSection.style.display = hasAny ? 'block' : 'none';

            // ── 總資產列 ──
            const taBar = document.getElementById('total-assets-bar');
            if (taBar) {
                const stockTWD = stats.totalValueTWD || 0;
                const totalTWD = stockTWD + cashTWD + cryptoTWD + moxaTWD;
                const fmtTWD   = v => Math.round(v).toLocaleString('en-US');
                const taStock      = document.getElementById('ta-stock');
                const taCash       = document.getElementById('ta-cash');
                const taCrypto     = document.getElementById('ta-crypto');
                const taCryptoWrap = document.getElementById('ta-crypto-wrap');
                const taMoxa       = document.getElementById('ta-moxa');
                const taMoxaWrap   = document.getElementById('ta-moxa-wrap');
                const taTotal      = document.getElementById('ta-total');
                if (taStock)  taStock.innerHTML  = pv(fmtTWD(stockTWD));
                if (taCash)   taCash.innerHTML   = pv(fmtTWD(cashTWD));
                const cashDisp = document.getElementById('cash-twd-display');
                if (cashDisp) cashDisp.textContent = Math.round(cashTWD).toLocaleString('en-US');
                if (taCrypto) taCrypto.innerHTML = pv(fmtTWD(cryptoTWD));
                if (taCryptoWrap) taCryptoWrap.style.display = cryptoTWD > 0 ? 'inline-flex' : 'none';
                if (taMoxa)   taMoxa.innerHTML   = pv(fmtTWD(moxaTWD));
                if (taMoxaWrap) taMoxaWrap.style.display = moxaTWD > 0 ? 'inline-flex' : 'none';
                if (taTotal)  taTotal.innerHTML  = pv(fmtTWD(totalTWD));
                taBar.style.display = hasAny ? 'flex' : 'none';
            }

            // ── USDT 換算提示 ──
            _updateCryptoHint();

            if (!hasAny) return;

            // ── 勾選框顏色 ──
            const cbLabel   = document.getElementById('cash-pie-cb-label');
            const cbWrap    = document.getElementById('cash-pie-label');
            const crLabel   = document.getElementById('crypto-pie-cb-label');
            const crWrap    = document.getElementById('crypto-pie-label');
            const mxLabel   = document.getElementById('moxa-pie-cb-label');
            const mxWrap    = document.getElementById('moxa-pie-label');
            if (cbLabel) cbLabel.style.color = showCashInPie   ? '#22c55e' : '#64748b';
            if (cbWrap)  cbWrap.style.borderColor  = showCashInPie   ? 'rgba(34,197,94,0.5)'   : 'rgba(34,197,94,0.25)';
            if (crLabel) crLabel.style.color = showCryptoInPie ? '#22c55e' : '#64748b';
            if (crWrap)  crWrap.style.borderColor  = showCryptoInPie ? 'rgba(34,197,94,0.5)' : 'rgba(34,197,94,0.25)';
            if (mxLabel) mxLabel.style.color = showMoxaInPie ? '#22c55e' : '#64748b';
            if (mxWrap)  mxWrap.style.borderColor  = showMoxaInPie ? 'rgba(34,197,94,0.5)' : 'rgba(34,197,94,0.25)';

            // ── 計算圓餅比例 ──
            const effectiveCash   = showCashInPie   ? cashTWD   : 0;
            const effectiveCrypto = showCryptoInPie ? cryptoTWD : 0;
            const effectiveMoxa   = showMoxaInPie   ? moxaTWD   : 0;
            const grandTotal = stats.totalValueTWD + effectiveCash + effectiveCrypto + effectiveMoxa;
            const stockScale = (grandTotal > 0 && stats.totalValueTWD > 0) ? stats.totalValueTWD / grandTotal : 1;
            const adjHoldings = stats.holdingsWithStats.map(h => ({ name: h.symbol, value: h.percentage * stockScale }));

            let pieData = adjHoldings.filter(d => d.value >= 0.5);
            let others  = adjHoldings.filter(d => d.value < 0.5).reduce((sum, d) => sum + d.value, 0);
            if (others > 0) pieData.push({ name: '其他', value: others });

            const cashColor   = '#22c55e';
            const cryptoColor = '#22c55e';
            const moxaColor   = '#22c55e';
            if (showCashInPie   && cashTWD   > 0 && grandTotal > 0)
                pieData.push({ name: '現金',     value: (cashTWD   / grandTotal) * 100, isCash:   true });
            if (showCryptoInPie && cryptoTWD  > 0 && grandTotal > 0)
                pieData.push({ name: '加密倉位', value: (cryptoTWD / grandTotal) * 100, isCrypto: true });
            if (showMoxaInPie   && moxaTWD    > 0 && grandTotal > 0)
                pieData.push({ name: '未上市股票', value: (moxaTWD   / grandTotal) * 100, isMoxa:   true });

            // 強制 100%
            const total = pieData.reduce((s, d) => s + d.value, 0);
            if (total > 0) pieData.forEach(d => d.value = (d.value / total) * 100);

            pieData.sort((a, b) => {
                if (a.name === '其他') return 1;
                if (b.name === '其他') return -1;
                return b.value - a.value;
            });

            const colors    = ['#3b82f6','#8b5cf6','#10b981','#3b82f6','#ef4444','#06b6d4','#ec4899','#14b8a6','#f97316','#6366f1'];
            const pieColors = pieData.map((d, i) => d.isCash ? cashColor : d.isCrypto ? cryptoColor : d.isMoxa ? moxaColor : colors[i % colors.length]);

            if (chartInstance) chartInstance.destroy();
            const ctx = document.getElementById('pieCanvas');
            chartInstance = new Chart(ctx, {
                type: 'pie',
                data: {
                    labels: pieData.map(d => d.name),
                    datasets: [{ data: pieData.map(d => d.value), backgroundColor: pieColors, borderColor: '#060d1a', borderWidth: 3 }]
                },
                options: { responsive: true, maintainAspectRatio: false, plugins: { legend: { display: false } } }
            });

            const legendHTML = pieData.map((d, i) => {
                const color = pieColors[i];
                const subLabel = d.isCash
                    ? `<span style="color:#a8bdd0;font-size:0.75rem;margin-left:0.25rem;">(${pv(cashTWD.toLocaleString('zh-TW',{maximumFractionDigits:0}) + ' TWD')})</span>`
                    : d.isCrypto && _usdtTWD > 0
                    ? `<span style="color:#a8bdd0;font-size:0.75rem;margin-left:0.25rem;">(${pv('≈' + (cryptoTWD/_usdtTWD).toLocaleString('en-US',{maximumFractionDigits:0}) + ' USDT')})</span>`
                    : '';
                return `
                <div style="display:flex; align-items:center; justify-content:space-between; gap:0.5rem; padding:0.22rem 0.55rem; background:rgba(15,23,42,0.3); border-radius:4px; font-size:0.82rem; border-left:3px solid ${color};">
                    <div style="display:flex; align-items:center; gap:0.35rem; flex-wrap:wrap;">
                        <div style="width:7px;height:7px;border-radius:2px;background:${color};flex-shrink:0;"></div>
                        <span style="color:#e2e8f0;font-weight:600;">${d.name}</span>${subLabel}
                    </div>
                    <span style="color:#3b82f6;font-weight:600;white-space:nowrap;">${d.value.toFixed(2)}%</span>
                </div>`;
            }).join('');
            document.getElementById('pie-legend').innerHTML = legendHTML;

            // 更新圓餅快照
            const _cbCash   = document.getElementById('cash-pie-cb')?.checked   ?? false;
            const _cbCrypto = document.getElementById('crypto-pie-cb')?.checked ?? false;
            const _cbMoxa   = document.getElementById('moxa-pie-cb')?.checked   ?? false;
            const _effCash   = _cbCash   ? cashTWD   : 0;
            const _effCrypto = _cbCrypto ? cryptoTWD : 0;
            const _effMoxa   = _cbMoxa   ? moxaTWD   : 0;
            const _grand = stats.totalValueTWD + _effCash + _effCrypto + _effMoxa;
            _pieSnapshot = {
                count:    stats.holdingsWithStats.length,
                currency,
                privacyMode: _privacyMode,
                cash:     cashTWD, crypto: cryptoTWD, moxa: moxaTWD,
                cbCash:   _cbCash, cbCrypto: _cbCrypto, cbMoxa: _cbMoxa,
                ratios:   Object.fromEntries(
                    // v15.076 P0-2：欄位名修正 valueTWD → valueTotalTWD（與 _shouldRenderPie 對齊）
                    stats.holdingsWithStats.map(h => [h.id, _grand > 0 ? h.valueTotalTWD / _grand : 0])
                )
            };
            _lastPieRenderTime = Date.now();
        }

        function renderAll() {
            const stats = calculateStats();
            renderStats(stats);
            renderTable(stats);
            renderHoldingsDetail(stats);
            if (_shouldRenderPie(stats)) renderPie(stats);
            document.getElementById('table-section').style.display = holdings.length > 0 ? 'block' : 'none';
            document.getElementById('rate-usd-twd').textContent = exchangeRates.USD_TWD.toFixed(2);
            document.getElementById('rate-hkd-twd').textContent = exchangeRates.HKD_TWD.toFixed(4);
            // 重新套用隱藏狀態（渲染後 DOM 可能被重建）
            const wrapper = document.getElementById('table-body-wrapper');
            const tableBtn = document.getElementById('toggle-table-btn');
            if (wrapper) wrapper.style.display = _tableHidden ? 'none' : '';
            if (tableBtn) tableBtn.textContent = _tableHidden ? '▼ 顯示' : '▲ 隱藏';
            const list = document.getElementById('holdings-list');
            const visBtn = document.getElementById('toggle-visible-btn');
            const allBtn = document.getElementById('toggle-all-btn');
            if (list) list.style.display = _holdingsHidden ? 'none' : '';
            if (visBtn) visBtn.textContent = _holdingsHidden ? '▼ 顯示持倉' : '▲ 隱藏';
            if (allBtn) {
                allBtn.style.opacity = _holdingsHidden ? '0.35' : '1';
                allBtn.style.pointerEvents = _holdingsHidden ? 'none' : '';
            }
            _updateSyncTimeLabels();
            // v15.069：嘗試擷取已收盤市場的當日損益快照（同一 marketDate 只會寫一次）
            try { _maybeCaptureDailyPnlSnapshots(stats); } catch(_) {}
            // v15.022：防抖儲存，500ms 內多次 renderAll 只寫一次 localStorage
            clearTimeout(_saveStorageTimer);
            _saveStorageTimer = setTimeout(saveToStorage, 500);
        }

        // ==================== 現金 / 存款 ====================
        const PT_CASH_KEY       = 'pt_v13_cash';      // 保留向下相容（已棄用，改由存款計算）
        const PT_CASH_PIE_KEY   = 'pt_cash_pie_cb';
        const PT_DEPOSITS_KEY   = 'pt_deposits';
        let deposits = [];
        const PT_CRYPTO_KEY     = 'pt_crypto_twd';
        const PT_CRYPTO_PIE_KEY = 'pt_crypto_pie_cb';
        const PT_MOXA_KEY       = 'pt_moxa_twd';
        const PT_WATCHLIST_KEY      = 'pt_watchlist';
        const PT_TRADE_HISTORY_KEY  = 'pt_trade_history';
        const PT_MOXA_PIE_KEY   = 'pt_moxa_pie_cb';

        // ── USDT/TWD 即時匯率（CoinGecko，備援用 USD/TWD）──
        let _usdtTWD = null;
        async function fetchUsdtRate() {
            try {
                const r = await fetch(
                    'https://api.coingecko.com/api/v3/simple/price?ids=tether&vs_currencies=twd',
                    { signal: AbortSignal.timeout(8000) }
                );
                if (r.ok) {
                    const d = await r.json();
                    const rate = d?.tether?.twd;
                    if (rate && rate > 0) { _usdtTWD = rate; _updateCryptoHint(); return; }
                }
            } catch(_) {}
            // 備援：用 USD/TWD（USDT ≈ 1 USD）
            _usdtTWD = exchangeRates.USD_TWD || 32;
            _updateCryptoHint();
        }
        function _updateCryptoHint() {
            const cryptoTWD = parseFloat(document.getElementById('crypto-twd-input')?.value) || 0;
            const hint = document.getElementById('crypto-usdt-hint');
            if (!hint) return;
            if (cryptoTWD > 0 && _usdtTWD > 0) {
                const usdt = (cryptoTWD / _usdtTWD).toLocaleString('en-US', { maximumFractionDigits: 0 });
                hint.textContent = `≈ ${usdt} USDT`;
            } else {
                hint.textContent = '';
            }
        }

        function saveCrypto() {
            const v = parseFloat(document.getElementById('crypto-twd-input')?.value) || 0;
            if (v > 0) localStorage.setItem(PT_CRYPTO_KEY, v);
            else localStorage.removeItem(PT_CRYPTO_KEY);
            const cb = document.getElementById('crypto-pie-cb');
            if (cb) localStorage.setItem(PT_CRYPTO_PIE_KEY, cb.checked ? '1' : '0');
            _updateCryptoHint();
        }
        function loadCrypto() {
            const v = parseFloat(localStorage.getItem(PT_CRYPTO_KEY)) || 0;
            const el = document.getElementById('crypto-twd-input');
            if (el && v > 0) el.value = v;
            const cb = document.getElementById('crypto-pie-cb');
            if (cb) cb.checked = (localStorage.getItem(PT_CRYPTO_PIE_KEY) === '1');
        }

        function saveMoxa() {
            const v = parseFloat(document.getElementById('moxa-twd-input')?.value) || 0;
            if (v > 0) localStorage.setItem(PT_MOXA_KEY, v);
            else localStorage.removeItem(PT_MOXA_KEY);
            const cb = document.getElementById('moxa-pie-cb');
            if (cb) localStorage.setItem(PT_MOXA_PIE_KEY, cb.checked ? '1' : '0');
        }
        function loadMoxa() {
            const v = parseFloat(localStorage.getItem(PT_MOXA_KEY)) || 0;
            const el = document.getElementById('moxa-twd-input');
            if (el && v > 0) el.value = v;
            const cb = document.getElementById('moxa-pie-cb');
            if (cb) cb.checked = (localStorage.getItem(PT_MOXA_PIE_KEY) === '1');
        }

        function saveCash() {
            // 現金金額由存款頁籤自動計算，只需儲存圓餅圖勾選狀態
            const cb = document.getElementById('cash-pie-cb');
            if (cb) localStorage.setItem(PT_CASH_PIE_KEY, cb.checked ? '1' : '0');
        }
        function loadCash() {
            const cb = document.getElementById('cash-pie-cb');
            if (cb) cb.checked = (localStorage.getItem(PT_CASH_PIE_KEY) === '1');
        }

        // ==================== 存款 ====================
        const _DEPOSIT_CURRENCIES = [
            { code: 'TWD', name: '台幣' },
            { code: 'USD', name: '美元' },
            { code: 'HKD', name: '港幣' },
            { code: 'JPY', name: '日圓' },
            { code: 'EUR', name: '歐元' },
            { code: 'SGD', name: '新加坡元' },
            { code: 'AUD', name: '澳幣' },
            { code: 'CNY', name: '人民幣' },
        ];
        function _depositToTWD(d) {
            const amt = d.amount || 0;
            if (d.currency === 'TWD') return amt;
            if (d.currency === 'USD') return amt * exchangeRates.USD_TWD;
            if (d.currency === 'HKD') return amt * exchangeRates.HKD_TWD;
            const extra = exchangeRates.extra || {};
            return extra[d.currency] ? amt * extra[d.currency] : 0;
        }
        function _depositsTWD() {
            return deposits.reduce((s, d) => s + _depositToTWD(d), 0);
        }
        function saveDeposits() {
            localStorage.setItem(PT_DEPOSITS_KEY, JSON.stringify(deposits));
        }
        function loadDeposits() {
            try { deposits = JSON.parse(localStorage.getItem(PT_DEPOSITS_KEY)) || []; } catch(_) { deposits = []; }
        }
        function addDeposit() {
            const bank = document.getElementById('dep-bank-input')?.value.trim();
            const currency = document.getElementById('dep-currency-select')?.value || 'TWD';
            const amount = parseFloat(document.getElementById('dep-amount-input')?.value);
            if (!bank) return;
            if (isNaN(amount) || amount <= 0) return;
            deposits.push({ id: Date.now(), bank, currency, amount });
            saveDeposits();
            _markAndAutoPush(['deposits']);
            document.getElementById('dep-bank-input').value = '';
            document.getElementById('dep-amount-input').value = '';
            renderDepositsTab();
            renderAll();
        }
        function removeDeposit(id) {
            deposits = deposits.filter(d => d.id !== id);
            saveDeposits();
            _markAndAutoPush(['deposits']);
            renderDepositsTab();
            renderAll();
        }
        function updateDepositAmount(id, val) {
            const amt = parseFloat(val);
            if (isNaN(amt) || amt < 0) return;
            const dep = deposits.find(d => d.id === id);
            if (!dep) return;
            dep.amount = amt;
            saveDeposits();
            _markAndAutoPush(['deposits']);
            renderDepositsTab();
            renderAll();
        }
        function renderDepositsTab() {
            const pane = document.getElementById('tab-pane-7');
            if (!pane) return;
            const totalTWD = _depositsTWD();
            const fmtN = v => Math.round(v).toLocaleString('en-US');
            const fmtAmt = (v, cur) => cur === 'TWD'
                ? Math.round(v).toLocaleString('en-US')
                : v.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
            const currencyOptions = _DEPOSIT_CURRENCIES.map(c =>
                `<option value="${c.code}">${c.code} ${c.name}</option>`).join('');
            const rowsHtml = deposits.length === 0
                ? `<div style="text-align:center;padding:1.5rem;color:#607585;font-size:0.88rem;">尚無存款紀錄，請在上方新增</div>`
                : deposits.map(d => {
                    const twdVal = _depositToTWD(d);
                    const rawAmt = d.currency === 'TWD' ? Math.round(d.amount) : d.amount;
                    return `
                    <div style="display:grid;grid-template-columns:1fr auto auto auto;gap:0.5rem 0.75rem;align-items:center;padding:0.7rem 0;border-bottom:1px solid rgba(255,255,255,0.05);">
                        <div>
                            <div style="color:#e2e8f0;font-weight:600;font-size:0.9rem;">${d.bank}</div>
                            <div style="color:#7e93a6;font-size:0.75rem;">${d.currency}</div>
                        </div>
                        <input type="number" class="mono pv-field"
                            value="${rawAmt}"
                            onchange="updateDepositAmount(${d.id}, this.value)"
                            style="width:110px;text-align:right;padding:0.28rem 0.5rem;background:rgba(6,13,26,0.85);border:1px solid rgba(56,139,253,0.25);border-radius:6px;color:#f1f5f9;font-size:0.88rem;outline:none;">
                        <div style="text-align:right;min-width:60px;">${d.currency !== 'TWD' ? `<span class="mono" style="color:#607585;font-size:0.78rem;">${pv('≈ NT$' + fmtN(twdVal))}</span>` : ''}</div>
                        <button onclick="removeDeposit(${d.id})" style="padding:0.25rem 0.6rem;background:rgba(239,68,68,0.1);border:1px solid rgba(239,68,68,0.25);border-radius:6px;color:#f87171;font-size:0.82rem;cursor:pointer;text-transform:none;letter-spacing:0;">×</button>
                    </div>`;
                }).join('');
            const totalRow = deposits.length > 0 ? `
                <div style="display:flex;justify-content:space-between;align-items:center;padding:0.65rem 0 0;margin-top:0.15rem;border-top:1px solid rgba(255,255,255,0.08);">
                    <span style="color:#7e93a6;font-size:0.82rem;">合計（TWD）</span>
                    <span class="mono" style="color:#60a5fa;font-size:1rem;font-weight:700;">${pv('NT$ ' + fmtN(totalTWD))}</span>
                </div>` : '';
            pane.innerHTML = `
            <div class="glass-card" style="padding:1.25rem 1.5rem; margin-bottom:1rem;">
                <div style="margin-bottom:1rem;">
                    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:0.6rem;">
                        <h2 style="color:#f1f5f9;font-size:1.1rem;font-weight:600;margin:0;"><i class="ic">▦</i> 存款管理</h2>
                        <div style="display:flex;gap:0.45rem;align-items:center;">
                            ${_pvBtnHtml()}
                        </div>
                    </div>
                    <div style="color:#7e93a6;font-size:0.72rem;margin-bottom:0.2rem;letter-spacing:0.04em;">存款合計（約合 TWD）</div>
                    <div class="mono" style="font-size:1.9rem;font-weight:800;color:#60a5fa;line-height:1;">${pv('NT$ ' + fmtN(totalTWD))}</div>
                    <div style="color:#607585;font-size:0.72rem;margin-top:0.3rem;">此金額自動連動至持倉管理的現金欄位</div>
                    <div id="deposits-sync-time" style="color:#607585;font-size:0.72rem;margin-top:0.25rem;">${_syncTimeText('deposits')}</div>
                </div>
                <div style="display:flex;gap:0.45rem;align-items:center;flex-wrap:wrap;padding:0.85rem 0;border-top:1px solid rgba(255,255,255,0.06);border-bottom:1px solid rgba(255,255,255,0.06);margin-bottom:0.5rem;">
                    <input id="dep-bank-input" type="text" placeholder="銀行 / 帳戶名稱" onkeydown="if(event.key==='Enter')addDeposit()" style="flex:1;min-width:110px;padding:0.38rem 0.6rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.22);border-radius:7px;color:#e2e8f0;font-size:0.82rem;outline:none;">
                    <select id="dep-currency-select" style="padding:0.38rem 0.4rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.22);border-radius:7px;color:#a8bdd0;font-size:0.8rem;outline:none;cursor:pointer;">${currencyOptions}</select>
                    <input id="dep-amount-input" type="number" min="0" placeholder="金額" onkeydown="if(event.key==='Enter')addDeposit()" style="width:110px;padding:0.38rem 0.6rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.22);border-radius:7px;color:#e2e8f0;font-size:0.82rem;outline:none;">
                    <button onclick="addDeposit()" style="padding:0.38rem 0.9rem;background:rgba(56,139,253,0.15);border:1.5px solid rgba(56,139,253,0.35);border-radius:7px;color:#60a5fa;font-size:0.82rem;font-weight:700;cursor:pointer;text-transform:none;letter-spacing:0;white-space:nowrap;">+ 新增</button>
                </div>
                <div>${rowsHtml}</div>
                ${totalRow}
            </div>`;
        }

        // ==================== 觀察清單 ====================
        function saveWatchlist() {
            localStorage.setItem(PT_WATCHLIST_KEY, JSON.stringify(watchlist));
        }
        function loadWatchlist() {
            try { watchlist = JSON.parse(localStorage.getItem(PT_WATCHLIST_KEY)) || []; } catch(_) { watchlist = []; }
            renderWatchlist();
        }
        function toggleWatchlistVisible() {
            _watchlistHidden = !_watchlistHidden;
            const body = document.getElementById('watchlist-body');
            const btn  = document.getElementById('watchlist-toggle-btn');
            if (body) body.style.display = _watchlistHidden ? 'none' : '';
            if (btn)  btn.textContent = _watchlistHidden ? '▼ 顯示' : '▲ 隱藏';
        }
        function addToWatchlist() {
            const inp = document.getElementById('watchlist-symbol-input');
            const sym = (inp?.value || '').trim().toUpperCase();
            const market = document.getElementById('watchlist-market-select')?.value || 'US';
            if (!sym) return;
            if (watchlist.some(w => w.symbol === sym)) {
                inp.style.borderColor = '#ef4444';
                setTimeout(() => { inp.style.borderColor = ''; }, 1500);
                return;
            }
            watchlist.push({ symbol: sym, market });
            inp.value = '';
            saveWatchlist();
            renderWatchlist();
        }
        function removeFromWatchlist(sym) {
            watchlist = watchlist.filter(w => w.symbol !== sym);
            saveWatchlist();
            renderWatchlist();
        }
        function renderWatchlist() {
            const countEl = document.getElementById('watchlist-count');
            if (countEl) countEl.textContent = watchlist.length;
            const list = document.getElementById('watchlist-list');
            if (!list) return;
            if (watchlist.length === 0) {
                list.innerHTML = '<div style="color:#607585;font-size:0.82rem;text-align:center;padding:1.2rem 0;letter-spacing:0.03em;">尚無觀察標的 — 在上方輸入代號後點「新增」</div>';
                return;
            }
            list.innerHTML = watchlist.map(w => `
                <div style="display:flex;align-items:center;justify-content:space-between;padding:0.45rem 0.75rem;background:rgba(15,30,60,0.45);border:1px solid rgba(56,139,253,0.14);border-radius:8px;margin-bottom:0.3rem;transition:border-color 0.2s;" onmouseover="this.style.borderColor='rgba(96,165,250,0.3)'" onmouseout="this.style.borderColor='rgba(56,139,253,0.14)'">
                    <div style="display:flex;align-items:center;gap:0.55rem;">
                        <i class="ic" style="color:#60a5fa;">◎</i>
                        <span style="color:#e2e8f0;font-weight:700;font-size:0.92rem;">${w.symbol}</span>
                        <span style="color:#7e93a6;font-size:0.72rem;padding:0.1rem 0.38rem;background:rgba(56,139,253,0.1);border:1px solid rgba(56,139,253,0.18);border-radius:4px;">${w.market}</span>
                    </div>
                    <button onclick="removeFromWatchlist('${w.symbol}')" title="移除" style="background:rgba(239,68,68,0.1);border:1px solid rgba(239,68,68,0.25);border-radius:6px;color:#f87171;padding:0.18rem 0.48rem;font-size:0.78rem;cursor:pointer;line-height:1.4;text-transform:none;letter-spacing:0;">✕</button>
                </div>`).join('');
        }
        // ==================== 已實現損益 ====================
        function saveTradeHistory() {
            try { localStorage.setItem(PT_TRADE_HISTORY_KEY, JSON.stringify(tradeHistory)); } catch(_) {}
        }
        function loadTradeHistory() {
            try { tradeHistory = JSON.parse(localStorage.getItem(PT_TRADE_HISTORY_KEY)) || []; } catch(_) { tradeHistory = []; }
        }
        // ==================== 市值快照 & 期間報酬率 ====================
        const PT_SNAPSHOTS_KEY = 'pt_snapshots';

        function saveSnapshots() {
            try { localStorage.setItem(PT_SNAPSHOTS_KEY, JSON.stringify(marketSnapshots)); } catch(_) {}
        }
        function loadSnapshots() {
            try { marketSnapshots = JSON.parse(localStorage.getItem(PT_SNAPSHOTS_KEY)) || []; } catch(_) { marketSnapshots = []; }
        }

        // 計算目前所有股票持倉的台幣市值（不含加密/MOXA/現金）
        function _currentStockValueTWD() {
            return holdings.reduce((sum, h) => {
                let v = (h.currentPrice || 0) * (h.quantity || 0);
                if (h.market === 'US') v *= exchangeRates.USD_TWD;
                else if (h.market === 'HK') v *= exchangeRates.HKD_TWD;
                return sum + v;
            }, 0);
        }

        // ── 本地修改時間戳 & 自動推送（防止靜默拉取覆蓋未推送的本地修改）──
        const PT_SCHEMA_VERSION     = 1;   // Gist payload schema 版本號，每次欄位重命名或移除時 +1
        const PT_LOCAL_MODIFY_TS    = 'pt_local_modify_ts';
        const PT_PENDING_PUSH_COUNT = 'pt_pending_push_count';
        const PT_DEVICE_ID          = 'pt_device_id';
        const PT_LAST_CLOUD_REV     = 'pt_last_cloud_revision';
        const PT_LAST_CLOUD_TS      = 'pt_last_cloud_updated_at';
        const PT_DIRTY_DOMAINS      = 'pt_dirty_domains';
        const PT_DOMAIN_UPDATED_AT  = 'pt_domain_updated_at';
        const MAX_PUSH_RETRY = 5;
        let _autoPushTimer  = null;
        let _retryTimer     = null;
        let _pushRetryCount = 0;

        function _readJsonStorage(key, fallback) {
            try {
                const raw = localStorage.getItem(key);
                return raw ? JSON.parse(raw) : fallback;
            } catch(_) {
                return fallback;
            }
        }

        function _getDeviceId() {
            let id = localStorage.getItem(PT_DEVICE_ID);
            if (!id) {
                const c = window.crypto || window.msCrypto;
                id = (c?.randomUUID?.() || ('dev-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2)));
                localStorage.setItem(PT_DEVICE_ID, id);
            }
            return id;
        }

        function _getDirtyDomains() {
            // v15.079 hotfix：移除「pending > 0 → ['general']」fallback
            // 舊邏輯會讓殘留 pending count（v15.077/078 升級殘留）誤判為 user dirty，
            // 也會讓 hash 比對白費（hash 同但 dirty 不空 → 仍走 dirty 分支）
            return _readJsonStorage(PT_DIRTY_DOMAINS, []);
        }

        function _setDirtyDomains(domains) {
            const list = [...new Set((domains || []).filter(Boolean))];
            if (list.length) localStorage.setItem(PT_DIRTY_DOMAINS, JSON.stringify(list));
            else localStorage.removeItem(PT_DIRTY_DOMAINS);
        }

        function _markDomainsModified(domains, ts) {
            const list = Array.isArray(domains) && domains.length ? domains : ['general'];
            const updated = _readJsonStorage(PT_DOMAIN_UPDATED_AT, {});
            list.forEach(d => updated[d] = ts);
            localStorage.setItem(PT_DOMAIN_UPDATED_AT, JSON.stringify(updated));
            _setDirtyDomains([..._getDirtyDomains(), ...list]);
        }

        function _clearDirtyDomains() {
            localStorage.removeItem(PT_DIRTY_DOMAINS);
        }

        function _domainUpdatedAt(domain) {
            return _readJsonStorage(PT_DOMAIN_UPDATED_AT, {})[domain] || '';
        }

        function _fmtSyncTs(ts) {
            if (!ts) return '尚無紀錄';
            const d = new Date(ts);
            if (isNaN(d)) return '尚無紀錄';
            return d.toLocaleString('zh-TW', { month:'2-digit', day:'2-digit', hour:'2-digit', minute:'2-digit' });
        }

        function _syncTimeText(domain) {
            const localTs = _domainUpdatedAt(domain);
            const cloudTs = localStorage.getItem(PT_LAST_CLOUD_TS) || '';
            const dirty = _getDirtyDomains().includes(domain);
            const localPart = localTs ? `本機 ${_fmtSyncTs(localTs)}` : '本機尚無修改';
            const cloudPart = cloudTs ? `雲端 ${_fmtSyncTs(cloudTs)}` : '雲端尚未確認';
            return `${dirty ? '未同步 · ' : ''}${localPart} ｜ ${cloudPart}`;
        }

        function _updateSyncTimeLabels() {
            const h = document.getElementById('holdings-sync-time');
            if (h) {
                h.textContent = _syncTimeText('holdings');
                h.style.color = _getDirtyDomains().includes('holdings') ? '#fbbf24' : '#607585';
            }
            const d = document.getElementById('deposits-sync-time');
            if (d) {
                d.textContent = _syncTimeText('deposits');
                d.style.color = _getDirtyDomains().includes('deposits') ? '#fbbf24' : '#607585';
            }
        }

        function _gistRevision(data) {
            return data?.history?.[0]?.version || data?.updated_at || '';
        }

        function _rememberCloudState(data) {
            const rev = _gistRevision(data);
            if (rev) localStorage.setItem(PT_LAST_CLOUD_REV, rev);
            if (data?.updated_at) localStorage.setItem(PT_LAST_CLOUD_TS, data.updated_at);
            _updateSyncTimeLabels();
        }

        function _applyCloudDomainTimes(saved, fallbackTs) {
            const updated = _readJsonStorage(PT_DOMAIN_UPDATED_AT, {});
            const domains = ['holdings', 'deposits', 'tradeHistory', 'watchlist', 'settings', 'marketSnapshots', 'general'];
            const appliedAt = saved?.sync_meta?.pushedAt || saved?.pushedAt || fallbackTs;
            domains.forEach(d => {
                const ts = saved?.sync_meta?.domains?.[d]?.updatedAt || appliedAt;
                if (ts) updated[d] = ts;
            });
            localStorage.setItem(PT_DOMAIN_UPDATED_AT, JSON.stringify(updated));
            if (appliedAt) localStorage.setItem(PT_LOCAL_MODIFY_TS, appliedAt);
        }

        // v15.079：async — 加 userDataHashVersion / userDataHash / userConfirmedCloudMaster
        async function _buildSyncMeta(pushedAt, domains, opts) {
            const domainUpdatedAt = _readJsonStorage(PT_DOMAIN_UPDATED_AT, {});
            // v15.071：加入 dailyPnlSnapshots dirty domain
            const allDomains = ['holdings', 'deposits', 'tradeHistory', 'watchlist', 'settings', 'marketSnapshots', 'dailyPnlSnapshots', 'general'];
            const domainMeta = {};
            allDomains.forEach(d => domainMeta[d] = { updatedAt: domainUpdatedAt[d] || null });
            const userDataHash = (opts && opts.userDataHash) || await _userDataHash(_buildLocalUserPayload());
            return {
                metadata_version: 1,
                pushedAt,
                pushedByDeviceId: _getDeviceId(),
                baseCloudRevision: localStorage.getItem(PT_LAST_CLOUD_REV) || '',
                baseCloudUpdatedAt: localStorage.getItem(PT_LAST_CLOUD_TS) || '',
                dirtyDomains: domains || _getDirtyDomains(),
                domains: domainMeta,
                // v15.079：userDataHash + master flag（master 只由「標記最新版」push 寫入）
                userDataHashVersion: 1,
                userDataHash,
                userConfirmedCloudMaster: (opts && opts.userConfirmedCloudMaster) || null
            };
        }

        async function _fetchGistState(token, gistId) {
            const res = await fetch(`https://api.github.com/gists/${gistId}`, {
                headers: {
                    'Authorization': `token ${token}`,
                    'Accept': 'application/vnd.github.v3+json'
                },
                cache: 'no-store'
            });
            if (!res.ok) {
                const err = await res.json().catch(() => ({}));
                const e = new Error(err.message || `HTTP ${res.status}`);
                e.status = res.status;   // v15.062：保留 HTTP status 給 _isAuthError / _recordPushError 判斷
                throw e;
            }
            const data = await res.json();
            const gistFile = data.files?.[GIST_FILENAME];
            let saved = null;
            if (gistFile) {
                if (gistFile.content && !gistFile.truncated) {
                    saved = JSON.parse(gistFile.content);
                } else {
                    const fileRes = await fetch(gistFile.raw_url, { cache: 'no-store' });
                    if (!fileRes.ok) throw new Error('讀取檔案失敗');
                    saved = await fileRes.json();
                }
            }
            return { data, saved, cloudRevision: _gistRevision(data), cloudUpdatedAt: data.updated_at || saved?.pushedAt || '' };
        }

        function _cloudChangedSinceBase(state) {
            const base = localStorage.getItem(PT_LAST_CLOUD_REV) || '';
            return !!(state?.cloudRevision && base && state.cloudRevision !== base);
        }

        // ────────────────────────────────────────────────────────
        // v15.075：同步狀態 classifier — 用 GitHub Gist revision SHA 判斷本機/雲端是否真衝突
        // 取代「dirty 一律 reject」舊設計，避免 user 多裝置切換時被永久卡住
        // ────────────────────────────────────────────────────────
        function _getLocalSyncState() {
            return {
                dirtyDomains:       _getDirtyDomains(),
                pendingPushCount:   parseInt(localStorage.getItem(PT_PENDING_PUSH_COUNT) || '0', 10),
                baseCloudRevision:  localStorage.getItem(PT_LAST_CLOUD_REV) || '',
                baseCloudUpdatedAt: localStorage.getItem(PT_LAST_CLOUD_TS) || ''
            };
        }
        // 輸入 _fetchGistState 結果 → 6 種狀態之一
        function _classifyCloudSyncState(gistState) {
            const local = _getLocalSyncState();
            const cloudRev = (gistState && gistState.cloudRevision) || '';
            const dirty = local.dirtyDomains.length > 0 || local.pendingPushCount > 0;
            if (!cloudRev) return dirty ? 'dirty_no_cloud' : 'clean_no_cloud';
            if (!local.baseCloudRevision) return 'no_cloud_base';
            const same = cloudRev === local.baseCloudRevision;
            if (!dirty && same)   return 'clean_cloud_same';
            if (!dirty && !same)  return 'clean_cloud_newer';
            if (dirty && same)    return 'dirty_cloud_same';
            return 'dirty_cloud_newer_conflict';
        }

        // ────────────────────────────────────────────────────────
        // v15.079：userDataHash + master flag 系列
        // 設計：以使用者資料內容 hash 取代 revision/pushedAt 作為主判斷
        // 不入 hash：marketSnapshots / daily_pnl_snapshots / pushedAt / sync_meta / 報價 / FX / 分析快取
        // ────────────────────────────────────────────────────────
        // v15.079 hotfix：normalize holding — 只取庫存「結構欄位」進 hash，
        // 排除動態報價（currentPrice / prevClose / prevPrevClose / dayPnL / marketOpenedToday 等）
        // 否則 silentRefreshPrices / runAnalysis 寫入即時報價會導致 hash 變動，誤判為 user data 不同
        function _normalizeHoldingForHash(h) {
            if (!h || typeof h !== 'object') return null;
            return {
                id:         h.id || null,
                symbol:     h.symbol || '',
                market:     h.market || '',
                quantity:   h.quantity ?? 0,
                costPrice:  h.costPrice ?? 0,
                lots:       Array.isArray(h.lots) ? h.lots.map(l => ({
                    qty:   l.qty   ?? l.quantity ?? 0,
                    cost:  l.cost  ?? l.costPrice ?? 0,
                    date:  l.date  || ''
                })) : [],
                addedDate:  h.addedDate || '',
                persist:    !!h.persist,
                name:       h.name || ''
            };
        }
        function _normalizeHoldingsForHash(arr) {
            return Array.isArray(arr) ? arr.map(_normalizeHoldingForHash) : [];
        }
        function _buildLocalUserPayload() {
            return {
                holdings:      _normalizeHoldingsForHash(holdings),
                watchlist,
                tradeHistory,
                deposits,
                currency,
                sheet_url:     document.getElementById('sheet-url')?.value?.trim() || '',
                cash_pie_cb:   document.getElementById('cash-pie-cb')?.checked  || false,
                crypto_twd:    parseFloat(document.getElementById('crypto-twd-input')?.value) || 0,
                crypto_pie_cb: document.getElementById('crypto-pie-cb')?.checked || false,
                moxa_twd:      parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0,
                moxa_pie_cb:   document.getElementById('moxa-pie-cb')?.checked   || false
            };
        }
        function _extractUserDataFromGistPayload(payload) {
            if (!payload || typeof payload !== 'object') return null;
            return {
                holdings:      _normalizeHoldingsForHash(payload.holdings),   // 同步排除雲端 payload 內的動態報價欄位
                watchlist:     payload.watchlist    || [],
                tradeHistory:  payload.tradeHistory || [],
                deposits:      payload.deposits     || {},
                currency:      payload.currency     || 'USD',
                sheet_url:     payload.sheet_url    || '',
                cash_pie_cb:   payload.cash_pie_cb  ?? false,
                crypto_twd:    payload.crypto_twd   ?? 0,
                crypto_pie_cb: payload.crypto_pie_cb ?? false,
                moxa_twd:      payload.moxa_twd     ?? 0,
                moxa_pie_cb:   payload.moxa_pie_cb  ?? false
            };
        }
        // 遞迴排序物件 keys（陣列順序保留），讓 JSON.stringify 結果穩定
        function _canonicalize(obj) {
            if (obj === null || typeof obj !== 'object') return obj;
            if (Array.isArray(obj)) return obj.map(_canonicalize);
            const out = {};
            Object.keys(obj).sort().forEach(k => { out[k] = _canonicalize(obj[k]); });
            return out;
        }
        async function _userDataHash(userData) {
            if (!userData) return null;
            try {
                const canonical = JSON.stringify(_canonicalize(userData));
                const buf = new TextEncoder().encode(canonical);
                const hashBuf = await crypto.subtle.digest('SHA-256', buf);
                return Array.from(new Uint8Array(hashBuf))
                    .map(b => b.toString(16).padStart(2, '0')).join('');
            } catch(e) {
                console.warn('[UserDataHash] failed', e);
                return null;
            }
        }
        // hash-first classify：hash 同 → 'hash_match'；不同 → fallback 既有 6-state
        // v15.080 後續修補：新增 'cloud_user_same_system_newer' — cloud user data 與本機上次同步過的版本一致
        // （system sync 期間累積的 revision 變動），允許 user push 不再 reject
        async function _classifyCloudSyncStateV2(gistState) {
            const cloudPayload = gistState?.saved || null;
            let cloudHash = cloudPayload?.sync_meta?.userDataHash || null;
            if (!cloudHash && cloudPayload) {
                cloudHash = await _userDataHash(_extractUserDataFromGistPayload(cloudPayload));
            }
            const localHash = await _userDataHash(_buildLocalUserPayload());
            if (cloudHash && localHash && cloudHash === localHash) {
                return { kind: 'hash_match', cloudRevision: gistState.cloudRevision || '', cloudUpdatedAt: gistState.cloudUpdatedAt || '', cloudHash, localHash };
            }
            const lastUserHash = localStorage.getItem(STORAGE_KEYS.lastUserDataHash);
            if (cloudHash && lastUserHash && cloudHash === lastUserHash && localHash !== cloudHash) {
                return { kind: 'cloud_user_same_system_newer', cloudRevision: gistState.cloudRevision || '', cloudUpdatedAt: gistState.cloudUpdatedAt || '', cloudHash, localHash };
            }
            return { kind: _classifyCloudSyncState(gistState), cloudHash, localHash };
        }
        // ────────────────────────────────────────────────────────
        // v15.079：master flag 處理（已處理 id 集合 + rollback summary）
        // ────────────────────────────────────────────────────────
        function _getProcessedMasterIds() {
            try { return new Set(JSON.parse(localStorage.getItem(STORAGE_KEYS.processedMasterIds) || '[]')); }
            catch(_) { return new Set(); }
        }
        function _addProcessedMasterId(id) {
            if (!id) return;
            const s = _getProcessedMasterIds();
            s.add(id);
            // 滾動保留最近 50 筆
            const arr = [...s];
            const kept = arr.length > 50 ? arr.slice(-50) : arr;
            localStorage.setItem(STORAGE_KEYS.processedMasterIds, JSON.stringify(kept));
        }
        function _isMasterIdProcessed(id) {
            return _getProcessedMasterIds().has(id);
        }
        function _saveRollbackSummary(summary) {
            localStorage.setItem(STORAGE_KEYS.rollbackSummary, JSON.stringify(summary));
        }
        function _loadRollbackSummary() {
            try { return JSON.parse(localStorage.getItem(STORAGE_KEYS.rollbackSummary) || 'null'); }
            catch(_) { return null; }
        }
        function _clearRollbackSummary() {
            localStorage.removeItem(STORAGE_KEYS.rollbackSummary);
        }

        // ────────────────────────────────────────────────────────
        // v15.080：System Sync Channel — daily_pnl_snapshots / baselines / price_cache
        //   • Gist 是 system data 唯一持久層；本機只用 memory cache
        //   • 不進 user dirty / pending / master flag
        //   • push 前 hash_match guard；hash 不同 abort + _recordAppError
        // ────────────────────────────────────────────────────────
        let _dailyPnlBaselines = null;     // { version, userDataHash, updatedAt, symbols: { sym: { market, prevClose, prevPrevClose, marketDate, fetchedAt, source } } }
        let _dailyPnlPriceCache = null;    // { version, updatedAt, symbols: { sym: { market, closes: [{ marketDate, close, fetchedAt, source }] (≤10) } } }
        let _systemSyncCooldownTs = 0;     // backfill 全域 cooldown 起算時間（3min）
        let _systemPushTimer = null;       // _scheduleSystemSyncPush debounce timer

        // 嚴格驗證雲端 system payload — 失敗只忽略 system 區塊，不影響 user data pull
        function _validateSystemPayload(payload) {
            if (!payload || typeof payload !== 'object') return { baselines: null, priceCache: null };
            const out = { baselines: null, priceCache: null };
            // baselines
            try {
                const b = payload.daily_pnl_baselines;
                if (b && typeof b === 'object' && b.symbols && typeof b.symbols === 'object') {
                    const symbols = {};
                    Object.entries(b.symbols).forEach(([sym, data]) => {
                        if (!data || typeof data !== 'object') return;
                        const pc = data.prevClose;
                        const ppc = data.prevPrevClose;
                        const okPc  = pc  === null || typeof pc  === 'number';
                        const okPpc = ppc === null || typeof ppc === 'number';
                        if (typeof data.market === 'string' && okPc && okPpc) symbols[sym] = data;
                    });
                    out.baselines = { ...b, symbols };
                }
            } catch(e) { _recordAppError('system_payload_validate', e, { section: 'baselines' }); }
            // price cache
            try {
                const c = payload.daily_pnl_price_cache;
                if (c && typeof c === 'object' && c.symbols && typeof c.symbols === 'object') {
                    const symbols = {};
                    Object.entries(c.symbols).forEach(([sym, data]) => {
                        if (!data || typeof data !== 'object' || !Array.isArray(data.closes)) return;
                        const closes = data.closes.filter(x =>
                            x && typeof x === 'object'
                            && typeof x.marketDate === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(x.marketDate)
                            && typeof x.close === 'number'
                        );
                        if (typeof data.market === 'string') symbols[sym] = { ...data, closes };
                    });
                    out.priceCache = { ...c, symbols };
                }
            } catch(e) { _recordAppError('system_payload_validate', e, { section: 'priceCache' }); }
            return out;
        }
        // hydrate window._prevCloseCache / _prevPrevCloseCache 從 baselines memory
        // v15.080 後續修補：marketDate 必須 === 該市場目前的 lastCompletedTradingDate
        // 否則跳過（避免使用過期 / 跨裝置寫錯的舊 baseline 把今日漲幅算成兩倍）
        function _hydratePrevCloseFromBaselines() {
            if (!_dailyPnlBaselines || !_dailyPnlBaselines.symbols) return;
            const pc  = window._prevCloseCache     || {};
            const ppc = window._prevPrevCloseCache || {};
            const now = new Date();
            Object.entries(_dailyPnlBaselines.symbols).forEach(([sym, data]) => {
                try {
                    const mk = data.market;
                    if (mk) {
                        const session = _marketSession(mk, now);
                        if (data.marketDate !== session.lastCompletedTradingDate) return;
                    }
                } catch(_) { return; }
                if (typeof data.prevClose     === 'number') pc[sym]  = data.prevClose;
                if (typeof data.prevPrevClose === 'number') ppc[sym] = data.prevPrevClose;
            });
            window._prevCloseCache     = pc;
            window._prevPrevCloseCache = ppc;
        }
        // 從雲端 payload merge system data 進 memory（pull 路徑共用）
        // v15.080 hotfix P1-2：用 merge 取代覆蓋，避免本機 partial 洗掉雲端較完整資料
        function _applySystemDataFromPayload(saved) {
            if (!saved) return;
            const v = _validateSystemPayload(saved);
            if (v.baselines)  _dailyPnlBaselines  = _mergeBaselines(_dailyPnlBaselines, v.baselines);
            if (v.priceCache) _dailyPnlPriceCache = _mergePriceCache(_dailyPnlPriceCache, v.priceCache);
            _hydratePrevCloseFromBaselines();
        }
        // baselines per-symbol merge：fetchedAt 較新優先；本機沒有就拿 remote 的
        function _mergeBaselines(local, remote) {
            const a = (local && local.symbols) || {};
            const b = (remote && remote.symbols) || {};
            const out = { version: 1, userDataHash: (local && local.userDataHash) || (remote && remote.userDataHash) || null, updatedAt: new Date().toISOString(), symbols: {} };
            const symbols = new Set([...Object.keys(a), ...Object.keys(b)]);
            symbols.forEach(sym => {
                const la = a[sym], lb = b[sym];
                if (la && lb) {
                    const ta = la.fetchedAt ? new Date(la.fetchedAt).getTime() : 0;
                    const tb = lb.fetchedAt ? new Date(lb.fetchedAt).getTime() : 0;
                    out.symbols[sym] = (ta >= tb) ? la : lb;
                } else {
                    out.symbols[sym] = la || lb;
                }
            });
            return out;
        }
        // price_cache per-symbol merge：close array 用 marketDate dedupe（取較新 fetchedAt），保留最後 10 個交易日
        function _mergePriceCache(local, remote) {
            const a = (local && local.symbols) || {};
            const b = (remote && remote.symbols) || {};
            const out = { version: 1, updatedAt: new Date().toISOString(), symbols: {} };
            const symbols = new Set([...Object.keys(a), ...Object.keys(b)]);
            symbols.forEach(sym => {
                const market = (a[sym] && a[sym].market) || (b[sym] && b[sym].market) || '';
                const closesA = (a[sym] && Array.isArray(a[sym].closes)) ? a[sym].closes : [];
                const closesB = (b[sym] && Array.isArray(b[sym].closes)) ? b[sym].closes : [];
                const map = {};
                [...closesA, ...closesB].forEach(c => {
                    if (!c || !c.marketDate || typeof c.close !== 'number') return;
                    const exist = map[c.marketDate];
                    if (!exist) { map[c.marketDate] = c; return; }
                    const te = exist.fetchedAt ? new Date(exist.fetchedAt).getTime() : 0;
                    const tn = c.fetchedAt ? new Date(c.fetchedAt).getTime() : 0;
                    if (tn > te) map[c.marketDate] = c;
                });
                const merged = Object.values(map).sort((x, y) => x.marketDate.localeCompare(y.marketDate));
                out.symbols[sym] = { market, closes: merged.slice(-10) };
            });
            return out;
        }

        // v15.080：system sync push（snapshot / baseline / price_cache）
        //   debounce 2s + _isApplyingCloudPull guard
        function _scheduleSystemSyncPush(reason) {
            if (_isApplyingCloudPull) return;
            clearTimeout(_systemPushTimer);
            _systemPushTimer = setTimeout(() => _systemSyncPush(reason), 2000);
        }
        async function _systemSyncPush(reason) {
            const token  = localStorage.getItem(GIST_TOKEN_KEY);
            const gistId = localStorage.getItem(GIST_ID_KEY);
            if (!token || !gistId) return false;
            try {
                // 1. fetch 最新 Gist + 比對 hash
                const state = await _fetchGistState(token, gistId);
                const localHash = await _userDataHash(_buildLocalUserPayload());
                // 2. 沒有雲端 saved（首次 Gist）→ system push 跳過（讓 user push 先建立 baseline）
                if (!state?.saved) return false;
                // 3. v15.080 hotfix P1-3：cloudHash 缺失（舊 Gist 無 sync_meta.userDataHash）時，從雲端 user data 即時計算
                //    禁止繞過 hash guard，避免本機 snapshot 是用別份庫存算的卻推上去
                let cloudHash = state.saved.sync_meta?.userDataHash || null;
                if (!cloudHash) {
                    try { cloudHash = await _userDataHash(_extractUserDataFromGistPayload(state.saved)); } catch(_) {}
                }
                if (!cloudHash || localHash !== cloudHash) {
                    _recordAppError('system_sync_hash_mismatch', new Error('local hash != cloud hash, abort system push'), {
                        reason,
                        cloudHash: (cloudHash || 'null').slice(0,12),
                        localHash: (localHash || 'null').slice(0,12)
                    });
                    return false;
                }
                // 4. v15.080 hotfix P1-2：merge remote + local system fields，避免本機 partial 洗掉雲端較完整資料
                const payload = { ...state.saved };
                // 4a. snapshots：用既有 _mergeDailyPnlSnapshots 完整性優先排序
                const localSnap  = _loadDailyPnlSnapshots();
                const remoteSnap = state.saved.daily_pnl_snapshots;
                payload.daily_pnl_snapshots = _mergeDailyPnlSnapshots(localSnap, remoteSnap, localHash);
                // 4b. baselines：per-symbol merge — 本機沒有 / 較舊就沿用 remote
                payload.daily_pnl_baselines = _mergeBaselines(_dailyPnlBaselines, state.saved.daily_pnl_baselines);
                // 4c. price_cache：per-symbol merge close arrays（dedupe by marketDate, keep latest fetchedAt, slice last 10）
                payload.daily_pnl_price_cache = _mergePriceCache(_dailyPnlPriceCache, state.saved.daily_pnl_price_cache);
                payload.system_meta = {
                    version: 1,
                    userDataHash: localHash,
                    updatedAt: new Date().toISOString(),
                    sourceDeviceId: _getDeviceId(),
                    reason
                };
                // 同步 merged 結果回本機 memory，下次 capture 看得到 remote
                try {
                    if (payload.daily_pnl_snapshots && payload.daily_pnl_snapshots.markets) _saveDailyPnlSnapshots(payload.daily_pnl_snapshots);
                    if (payload.daily_pnl_baselines)  _dailyPnlBaselines  = payload.daily_pnl_baselines;
                    if (payload.daily_pnl_price_cache) _dailyPnlPriceCache = payload.daily_pnl_price_cache;
                } catch(_) {}
                const res = await fetch(`https://api.github.com/gists/${gistId}`, {
                    method: 'PATCH',
                    headers: {
                        'Authorization': `token ${token}`,
                        'Content-Type': 'application/json',
                        'Accept': 'application/vnd.github.v3+json'
                    },
                    body: JSON.stringify({
                        description: 'Portfolio Tracker 持倉同步',
                        public: false,
                        files: { [GIST_FILENAME]: { content: JSON.stringify(payload, null, 2) } }
                    })
                });
                if (!res.ok) {
                    const e = new Error(`HTTP ${res.status}`);
                    e.status = res.status;
                    throw e;
                }
                // 5. 不寫 master flag、不更新 user baseline、不清 dirty / pending
                console.log(`[SystemSync] push ok (reason=${reason})`);
                return true;
            } catch(e) {
                _recordAppError(`system_sync_${reason}`, e);
                return false;
            }
        }

        // v15.080：補近期收盤價（新裝置 / 雲端缺料時用 Yahoo chart 補 baseline）
        //   • 全域 cooldown 3min；單 symbol 24hr 內有 close history 不重抓
        //   • 全部 active holdings 都有 close 才產生 complete=true snapshot
        //   • 失敗只 _recordAppError，不彈 toast、不增 pending
        const _BACKFILL_COOLDOWN_MS = 3 * 60 * 1000;
        const _BACKFILL_SYMBOL_TTL  = 24 * 60 * 60 * 1000;
        async function _backfillDailyPnlSystemData(reason) {
            const now = Date.now();
            if (now - _systemSyncCooldownTs < _BACKFILL_COOLDOWN_MS) return false;
            _systemSyncCooldownTs = now;
            try {
                if (!Array.isArray(holdings) || holdings.length === 0) return false;
                const byMarket = { TW: [], HK: [], US: [] };
                for (const h of holdings) {
                    const mk = _holdingMarketKey(h);
                    if (mk && byMarket[mk]) byMarket[mk].push(h);
                }
                if (!_dailyPnlPriceCache) _dailyPnlPriceCache = { version: 1, updatedAt: new Date().toISOString(), symbols: {} };
                if (!_dailyPnlBaselines)  _dailyPnlBaselines  = { version: 1, userDataHash: null, updatedAt: new Date().toISOString(), symbols: {} };

                // v15.080 hotfix P1-4：算 hash 一次 + 每市場結束直接建 complete snapshot
                let basisUserDataHash = null;
                let basisHoldingsHash = null;
                try { basisUserDataHash = await _userDataHash(_buildLocalUserPayload()); } catch(_) {}
                try { basisHoldingsHash = await _userDataHash({ holdings: _normalizeHoldingsForHash(holdings) }); } catch(_) {}

                let anyComplete = false;
                for (const mk of ['TW', 'HK', 'US']) {
                    const list = byMarket[mk];
                    if (!list || list.length === 0) continue;
                    const session = _marketSession(mk, new Date());
                    const target = session.lastCompletedTradingDate;
                    if (!target) continue;
                    if (_isTradingDay(mk, target) !== true) continue;
                    const prevTrading     = _previousTradingDate(mk, target);
                    const prevPrevTrading = prevTrading ? _previousTradingDate(mk, prevTrading) : null;
                    if (!prevTrading) continue;

                    // step 1：對每 symbol 抓 / 用 cache 補近 10 個交易日 close
                    for (const h of list) {
                        const sym = h.symbol;
                        const cached = _dailyPnlPriceCache.symbols[sym];
                        const recent = cached?.closes?.[cached.closes.length - 1];
                        const cacheFresh = !!(recent && recent.fetchedAt && (now - new Date(recent.fetchedAt).getTime() < _BACKFILL_SYMBOL_TTL));
                        if (cacheFresh) continue;     // 24hr 內已抓過，跳過
                        try {
                            const url = `https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(sym)}?interval=1d&range=1mo`;
                            const data = await yfFetch(url);
                            const result = data?.chart?.result?.[0];
                            const ts     = result?.timestamp || [];
                            const closes = result?.indicators?.quote?.[0]?.close || [];
                            if (!ts.length || !closes.length) continue;
                            const tz = _exchangeTz(sym);
                            const closeArr = [];
                            for (let i = 0; i < ts.length; i++) {
                                if (closes[i] == null) continue;
                                const d = new Date(ts[i] * 1000);
                                const md = new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }).format(d);
                                closeArr.push({ marketDate: md, close: closes[i], fetchedAt: new Date().toISOString(), source: 'yahoo-chart' });
                            }
                            const last10 = closeArr.slice(-10);
                            _dailyPnlPriceCache.symbols[sym] = { market: mk, closes: last10 };
                        } catch(_) { /* 單 symbol 失敗就略過 */ }
                    }

                    // step 2：從 price cache 算 baseline + 直接建 complete snapshot
                    // 語意（v15.080 後續修補）：
                    //   prevClose      = close[target]      ← 最近完成交易日收盤 = 今日 PnL basis
                    //   prevPrevClose  = close[prevTrading] ← 上一交易日 close = 昨日 PnL basis
                    //   snapshot pnl   = close[target] − close[prevTrading]（target 那天的當日損益）
                    const expectedHoldingsCount = list.length;
                    let pnlUSD = 0, pnlTWD = 0, withData = 0;
                    const usedHoldings = [];
                    const missingSymbols = [];
                    for (const h of list) {
                        const sym = h.symbol;
                        const cache = _dailyPnlPriceCache.symbols[sym];
                        const closes = cache?.closes || [];
                        const cTarget   = _extractCloseForDate(closes, target);
                        const cPrev     = _extractCloseForDate(closes, prevTrading);
                        const cPrevPrev = prevPrevTrading ? _extractCloseForDate(closes, prevPrevTrading) : null;
                        if (cTarget == null || cPrev == null) {
                            missingSymbols.push(sym);
                            continue;
                        }
                        // 寫 baseline（v15.080 後續修補：對齊 runAnalysis 未開盤路徑語意）
                        _dailyPnlBaselines.symbols[sym] = {
                            market: mk,
                            prevClose:     cTarget,      // close[target] = 最近完成交易日收盤 = 今日 PnL basis
                            prevPrevClose: cPrev,        // close[prevTrading] = 上一交易日 close = 昨日 PnL basis
                            marketDate: target,
                            fetchedAt: new Date().toISOString(),
                            source: 'backfill-price-history'
                        };
                        // 計算 pnl（close[target] − close[prevTrading]）
                        const _isHK_HKD = (h.market === 'HK' || (typeof sym === 'string' && sym.endsWith('.HK'))) && !HK_USD_PRICED.has(sym);
                        const dRaw = (cTarget - cPrev) * h.quantity;
                        let dUSD, dTWD;
                        if (_isHK_HKD)            { dUSD = dRaw * exchangeRates.HKD_TWD / exchangeRates.USD_TWD; dTWD = dRaw * exchangeRates.HKD_TWD; }
                        else if (h.market === 'TW') { dUSD = dRaw / exchangeRates.USD_TWD; dTWD = dRaw; }
                        else                       { dUSD = dRaw; dTWD = dRaw * exchangeRates.USD_TWD; }
                        pnlUSD += dUSD; pnlTWD += dTWD; withData++;
                        usedHoldings.push({ symbol: sym, quantity: h.quantity, currentPrice: cTarget, prevClose: cPrev, prevPrevClose: cPrevPrev });
                    }

                    const complete = (withData === expectedHoldingsCount) && expectedHoldingsCount > 0;
                    if (!complete) continue;   // partial 不寫 snapshot（仍保留 baselines 給 UI 顯示今日損益）

                    // step 3：直接寫 complete snapshot（不依賴 capture meta 對齊）
                    const snap = _loadDailyPnlSnapshots();
                    if (!snap.markets[mk]) snap.markets[mk] = { current: null, previous: null };
                    const slot = snap.markets[mk];
                    // 同 target 已有 complete snapshot 不覆蓋（本機既有更可信）
                    if (slot.current && slot.current.marketDate === target && slot.current.complete !== false) continue;
                    if (slot.current && slot.current.marketDate !== target) slot.previous = slot.current;
                    slot.current = {
                        marketKey: mk,
                        marketDate: target,
                        closedAt: new Date().toISOString(),
                        source: 'backfill-price-history',
                        pnlUSD, pnlTWD,
                        holdings: usedHoldings,
                        quoteStatus: 'fresh_after_close',
                        lastQuoteAt: null,
                        basisField: 'prevClose',
                        complete: true,
                        expectedHoldingsCount,
                        withData,
                        missingSymbols: [],
                        basisUserDataHash,
                        basisHoldingsHash
                    };
                    snap.lastCompleteDate = _computeLastCompleteDate(snap.markets);
                    _saveDailyPnlSnapshots(snap);
                    anyComplete = true;
                    console.log(`[Backfill] ${mk} complete snapshot built for ${target} (pnlTWD=${pnlTWD.toFixed(0)})`);
                }
                _dailyPnlPriceCache.updatedAt = new Date().toISOString();
                _dailyPnlBaselines.updatedAt  = new Date().toISOString();
                _hydratePrevCloseFromBaselines();
                if (anyComplete) {
                    try { _scheduleSystemSyncPush('daily_pnl_backfill'); } catch(_) {}
                    try { renderAll(); } catch(_) {}
                }
                return anyComplete;
            } catch(e) {
                _recordAppError('daily_pnl_backfill', e, { reason });
                return false;
            }
        }
        // 從 closes array 找指定 marketDate 的 close（精準對齊）
        function _extractCloseForDate(closes, targetDate) {
            if (!Array.isArray(closes) || !targetDate) return null;
            const hit = closes.find(c => c.marketDate === targetDate);
            return hit ? hit.close : null;
        }
        // v15.079：啟動 / pull 完成後呼叫，依 rollbackSummary 顯示 #rollback-card
        function _renderRollbackCard() {
            const card = document.getElementById('rollback-card');
            const info = document.getElementById('rollback-info');
            if (!card || !info) return;
            const sum = _loadRollbackSummary();
            if (!sum || !sum.masterId) {
                card.style.display = 'none';
                return;
            }
            const t = sum.createdAt ? new Date(sum.createdAt).toLocaleString('zh-TW') : '?';
            info.innerHTML = `偵測到本機回復點：標記於 <b style="color:#e2e8f0;">${t}</b>。<br>若這次「標記最新版」誤標，可還原本機到該雲端資料（不影響其他裝置）。`;
            card.style.display = 'block';
        }
        function _dismissRollback() {
            if (!confirm('確定不再需要這個回復點？\n\n清除後將無法回到標記前的雲端資料。')) return;
            const sum = _loadRollbackSummary();
            if (sum && sum.masterId) {
                try { _idbDeleteRollback(sum.masterId); } catch(_) {}
            }
            _clearRollbackSummary();
            _renderRollbackCard();
            showImportToast('已清除本機回復點', 1800);
        }
        async function _doRollback() {
            const sum = _loadRollbackSummary();
            if (!sum || !sum.masterId) { showWarnToast('回復點不存在'); return; }
            const r = await _idbGetRollback(sum.masterId);
            if (!r) { showWarnToast('IDB 內回復資料已遺失'); _clearRollbackSummary(); _renderRollbackCard(); return; }
            const t = sum.createdAt ? new Date(sum.createdAt).toLocaleString('zh-TW') : '?';
            const ok = confirm(`確定要還原本機資料到 ${t}（標記前的雲端內容）？\n\n注意：\n• 只還原本機，不會影響雲端與其他裝置\n• 還原後若要讓雲端也回復，請再選一次「標記最新版」`);
            if (!ok) return;
            await rollbackToBeforeMaster(sum.masterId, r);
        }
        async function rollbackToBeforeMaster(masterId, rollbackObj) {
            const r = rollbackObj || (await _idbGetRollback(masterId));
            if (!r) { showWarnToast('回復點已不存在'); return false; }
            const before = r.beforeCloudPayload;
            if (!before || typeof before !== 'object') {
                showWarnToast('回復資料不完整');
                return false;
            }
            _isApplyingCloudPull = true;
            try {
                // 套用 beforeCloudPayload 至本機（手動 pull 流程的子集）
                if (Array.isArray(before.holdings)) {
                    holdings = before.holdings;
                    holdings.forEach(h => { h.persist = true; try { _ensureLots(h); } catch(_) {} });
                }
                if (Array.isArray(before.watchlist)) { watchlist = before.watchlist; saveWatchlist(); }
                if (Array.isArray(before.tradeHistory)) { tradeHistory = before.tradeHistory; saveTradeHistory(); }
                if (Array.isArray(before.deposits)) { deposits = before.deposits; saveDeposits(); }
                if (Array.isArray(before.marketSnapshots)) { marketSnapshots = before.marketSnapshots; saveSnapshots(); }
                if (before.currency) currency = before.currency;
                if (before.exchangeRates) { exchangeRates = before.exchangeRates; try { syncRateInputs(); } catch(_) {} }
                if (before.sheet_url != null) {
                    const sheetEl = document.getElementById('sheet-url');
                    if (sheetEl) { sheetEl.value = before.sheet_url; try { saveSheetUrlSetting(); } catch(_) {} }
                }
                if (before.cash_pie_cb != null) {
                    localStorage.setItem(PT_CASH_PIE_KEY, before.cash_pie_cb ? '1' : '0');
                    const cb = document.getElementById('cash-pie-cb'); if (cb) cb.checked = !!before.cash_pie_cb;
                }
                if (before.crypto_twd != null) {
                    const v = before.crypto_twd || 0;
                    if (v > 0) localStorage.setItem(PT_CRYPTO_KEY, v); else localStorage.removeItem(PT_CRYPTO_KEY);
                    const el = document.getElementById('crypto-twd-input'); if (el) el.value = v > 0 ? v : '';
                }
                if (before.crypto_pie_cb != null) {
                    localStorage.setItem(PT_CRYPTO_PIE_KEY, before.crypto_pie_cb ? '1' : '0');
                    const cb = document.getElementById('crypto-pie-cb'); if (cb) cb.checked = !!before.crypto_pie_cb;
                }
                if (before.moxa_twd != null) {
                    const v = before.moxa_twd || 0;
                    if (v > 0) localStorage.setItem(PT_MOXA_KEY, v); else localStorage.removeItem(PT_MOXA_KEY);
                    const el = document.getElementById('moxa-twd-input'); if (el) el.value = v > 0 ? v : '';
                }
                if (before.moxa_pie_cb != null) {
                    localStorage.setItem(PT_MOXA_PIE_KEY, before.moxa_pie_cb ? '1' : '0');
                    const cb = document.getElementById('moxa-pie-cb'); if (cb) cb.checked = !!before.moxa_pie_cb;
                }
                // 標 master 處理 + 清回復點 + 不影響 Gist
                _addProcessedMasterId(masterId);
                await _idbDeleteRollback(masterId);
                _clearRollbackSummary();
                // 把本機 hash 重設為「還原後內容」對應 hash，供 silent push 之後判斷
                try {
                    const restoredHash = await _userDataHash(_buildLocalUserPayload());
                    if (restoredHash) localStorage.setItem(STORAGE_KEYS.lastUserDataHash, restoredHash);
                } catch(_) {}
                saveToStorage();
                // v15.079 hotfix：rollback 後本機與雲端內容不同（雲端仍是 master 那版）→
                // 標 user domains dirty 但「不」auto-push，由使用者自行選擇暫存或標記最新版
                try {
                    const ts = new Date().toISOString();
                    _markDomainsModified(['holdings', 'deposits', 'tradeHistory', 'watchlist', 'settings'], ts);
                    localStorage.setItem(PT_LOCAL_MODIFY_TS, ts);
                    const cur = parseInt(localStorage.getItem(PT_PENDING_PUSH_COUNT) || '0', 10);
                    localStorage.setItem(PT_PENDING_PUSH_COUNT, String(cur + 1));
                    _updatePendingPushIndicator();
                    _updateSyncTimeLabels();
                } catch(_) {}
                renderAll();
                _renderRollbackCard();
                showImportToast('✅ 已還原本機至標記前雲端資料（雲端未變動，請手動選擇推送方式）', 3500);
                return true;
            } finally {
                _isApplyingCloudPull = false;
            }
        }

        // push / pull 成功後統一寫 baseline + 清 dirty / pending；v15.079 加 lastUserDataHash
        function _applySyncBaseline(gistState, opts) {
            if (!gistState) return;
            try { if (gistState.data)  _rememberCloudState(gistState.data); } catch(_) {}
            try { if (gistState.saved) _applyCloudDomainTimes(gistState.saved, gistState.cloudUpdatedAt); } catch(_) {}
            _clearDirtyDomains();
            localStorage.setItem(PT_PENDING_PUSH_COUNT, '0');
            _updatePendingPushIndicator();
            // v15.079：寫 lastUserDataHash（caller 已算過就直接傳，否則 noop 留待下次自然寫入）
            try {
                const h = opts && opts.userDataHash;
                if (h) localStorage.setItem(STORAGE_KEYS.lastUserDataHash, h);
            } catch(_) {}
        }
        // v15.075：pull 套用期間防 dirty 反彈
        let _isApplyingCloudPull = false;

        function _showStaleReject(state) {
            const msg = `雲端已有新版（${_fmtSyncTs(state?.cloudUpdatedAt)}），本機不是基於最新版，已拒絕上傳。請先拉取雲端最新版再修改。`;
            setGistStatus(`❌ ${msg}`, '#ef4444');
            showWarnToast(`❌ ${msg}`, 5000);
        }

        // v15.075/079：preflight — 回傳 { action, state, kind, cloudHash, localHash }
        // action: 'push'（可推）/ 'noop'（hash_match 不必推）/ 'reject'（stale）
        async function _preflightGistPush(token, gistId) {
            if (!gistId) {
                return { action: 'push', state: { saved: null, data: null, cloudRevision: '', cloudUpdatedAt: '' }, kind: 'new', localHash: await _userDataHash(_buildLocalUserPayload()) };
            }
            const state = await _fetchGistState(token, gistId);
            if (!state.saved) {
                return { action: 'push', state, kind: 'no_cloud_payload', localHash: await _userDataHash(_buildLocalUserPayload()) };
            }
            const v2 = await _classifyCloudSyncStateV2(state);
            // v15.079：hash 相同 → 內容無變化，不必 PATCH
            // v15.080 後續修補：hash_match 順手清 dirty / pending（user 改了又改回原值的情境）
            // 不寫 PT_LAST_CLOUD_REV / lastUserDataHash（這些只在實際 push / pull apply 才動）
            if (v2.kind === 'hash_match') {
                try {
                    _clearDirtyDomains();
                    localStorage.setItem(PT_PENDING_PUSH_COUNT, '0');
                    _updatePendingPushIndicator();
                } catch(_) {}
                return { action: 'noop', state, kind: 'hash_match', cloudHash: v2.cloudHash, localHash: v2.localHash };
            }
            const cls = v2.kind;
            // v15.080 後續修補：cloud_user_same_system_newer 也放行 push（system sync 期間 revision 變動，user data 沒衝突）
            if (cls === 'clean_cloud_same' || cls === 'dirty_cloud_same' || cls === 'cloud_user_same_system_newer') {
                // preflight 通過時 merge 雲端 system data 進本機，避免 push 洗掉雲端較新值
                // v15.080 後續修補：擴大 merge 範圍至 baselines + price_cache（原本只 merge snapshots）
                try {
                    const sv = state.saved;
                    if (sv?.daily_pnl_snapshots?.markets) {
                        const merged = _mergeDailyPnlSnapshots(_loadDailyPnlSnapshots(), sv.daily_pnl_snapshots, v2.localHash);
                        _saveDailyPnlSnapshots(merged);
                    }
                    if (sv?.daily_pnl_baselines)   _dailyPnlBaselines  = _mergeBaselines(_dailyPnlBaselines,   sv.daily_pnl_baselines);
                    if (sv?.daily_pnl_price_cache) _dailyPnlPriceCache = _mergePriceCache(_dailyPnlPriceCache, sv.daily_pnl_price_cache);
                    _hydratePrevCloseFromBaselines();
                } catch(_) {}
                if (cls === 'cloud_user_same_system_newer') {
                    console.log('[Preflight] cloud_user_same_system_newer (system revision newer, user push allowed)');
                }
                return { action: 'push', state, kind: cls, cloudHash: v2.cloudHash, localHash: v2.localHash };
            }
            // 其餘狀態（no_cloud_base / clean_cloud_newer / dirty_cloud_newer_conflict）→ reject
            _showStaleReject(state);
            return { action: 'reject', state, kind: cls, cloudHash: v2.cloudHash, localHash: v2.localHash };
        }

        function _updatePendingPushIndicator() {
            const count = parseInt(localStorage.getItem(PT_PENDING_PUSH_COUNT) || '0', 10);
            const el = document.getElementById('pending-push-indicator');
            if (!el) return;
            if (count > 0) {
                const cEl = document.getElementById('pending-push-count');
                if (cEl) cEl.textContent = count;
                el.style.display = 'block';
            } else {
                el.style.display = 'none';
            }
        }

        function _retryPushNow() {
            _pushRetryCount = 0;
            clearTimeout(_retryTimer);
            _gistSilentPush();
        }

        // #region Gist Sync (manual + auto-push, retry, preflight)
        function _markLocalModified(domains) {
            // v15.075：pull 套用期間（renderAll / saveDeposits / saveTradeHistory 等被內部呼叫）不標 dirty
            // 否則拉雲端後立刻又 dirty，sync baseline 永遠對不齊
            if (_isApplyingCloudPull) return;
            const ts = new Date().toISOString();
            localStorage.setItem(PT_LOCAL_MODIFY_TS, ts);
            // v15.076 P0-1：pending count 從「呼叫次數」改成「多少類資料尚未同步」
            // 同 domain 重複呼叫只更新 ts，pending count 不再累加
            const before = new Set(_getDirtyDomains());
            _markDomainsModified(domains, ts);
            const after = new Set(_getDirtyDomains());
            let newDomains = 0;
            for (const d of after) if (!before.has(d)) newDomains++;
            if (newDomains > 0 && localStorage.getItem(GIST_TOKEN_KEY) && localStorage.getItem(GIST_ID_KEY)) {
                const curr = parseInt(localStorage.getItem(PT_PENDING_PUSH_COUNT) || '0', 10);
                localStorage.setItem(PT_PENDING_PUSH_COUNT, String(curr + newDomains));
                _updatePendingPushIndicator();
            }
            _updateSyncTimeLabels();
        }
        function _markAndAutoPush(domains) {
            // v15.075（codex P2）：pull 套用期間 renderAll() 可能觸發 _captureDailyPnlSnapshot 等
            // → 呼叫 _markAndAutoPush；_markLocalModified 已 guard 但 _scheduleAutoPush 仍會排 timer
            // 這裡再加一層 guard，避免 pull 完 2 秒後又偷偷 push（雖無 dirty/pending 但會多一筆 Gist revision）
            if (_isApplyingCloudPull) return;
            _markLocalModified(domains);
            _scheduleAutoPush();
            // v15.077：FSA 分流（GIST 已設或 FSA 未啟用會自動 noop）
            try { _markLocalSyncModified(domains); } catch(_) {}
            try { _scheduleLocalSyncPush(); } catch(_) {}
        }
        function _scheduleAutoPush() {
            if (!localStorage.getItem(GIST_TOKEN_KEY) || !localStorage.getItem(GIST_ID_KEY)) return;
            clearTimeout(_autoPushTimer);
            clearTimeout(_retryTimer);        // 新改動取代尚未執行的 retry
            _pushRetryCount = 0;               // 重置退避計數
            _autoPushTimer = setTimeout(() => {
                _gistSilentPush();
                console.log('[AutoPush] 本地修改已自動同步至 Gist');
            }, 2000);
        }

        // v15.064：統一應用錯誤紀錄（最多 50 筆，舊筆自動丟棄）
        // source: 'gist_push' / 'gist_pull' / 'csv_proxy_all_fail' / 'fundamentals_json_load' / 'render_health' 等
        // v15.065：加入 60s 內同 source+message 去重（避免 31 個 symbol 同輪刷新洗版錯誤日誌）
        // ────────────────────────────────────────────────────────
        // v15.066：PWA 版本更新偵測
        // 用 APP_VERSION（寫死）對網路上抓回的 HTML regex 比對，「打開就是舊版」也能提示
        // v15.068 修正：只在 remote 比 current 新時提示；GitHub Pages CDN 傳播延遲拿到舊版時靜默
        // ────────────────────────────────────────────────────────
        let _versionCheckTimer = null;
        let _lastVersionCheckErrorTs = 0;   // 同 source 6hr 內最多記 1 筆，避免離線時洗版錯誤日誌
        const _APP_VERSION_RE = /font-family:monospace;\s*pointer-events:none;">v(15\.\d{3})/;

        // v15.068：將 'v15.067' 解析為 [15, 67]
        function _parseAppVersion(v) {
            const m = (v || '').match(/v?(\d+)\.(\d+)/);
            if (!m) return null;
            return [parseInt(m[1], 10), parseInt(m[2], 10)];
        }
        // v15.068：判斷 remote 是否嚴格大於 current（避免 CDN 倒帶時誤判舊版為新版）
        function _isNewerVersion(remote, current) {
            const r = _parseAppVersion(remote);
            const c = _parseAppVersion(current);
            if (!r || !c) return false;
            if (r[0] !== c[0]) return r[0] > c[0];
            return r[1] > c[1];
        }

        async function _checkAppVersion() {
            // 離線跳過（navigator.onLine 不一定可靠但能濾掉明顯 case）
            if (typeof navigator !== 'undefined' && navigator.onLine === false) return;
            // 只在前台檢查，避免背景無謂打網路
            if (typeof document !== 'undefined' && document.visibilityState === 'hidden') return;

            try {
                const r = await fetch('./portfolio-tracker-v15.html?_=' + Date.now(), { cache: 'no-store' });
                if (!r.ok) throw new Error('HTTP ' + r.status);
                const txt = await r.text();
                const m = txt.match(_APP_VERSION_RE);
                if (!m) return;   // 抓不到版本字串，靜默
                const remoteVersion = 'v' + m[1];
                // v15.068 修正：只在嚴格新於本機時提示；CDN 邊緣節點回傳舊版時靜默繼續輪詢
                if (_isNewerVersion(remoteVersion, APP_VERSION)) {
                    _showVersionUpdateToast(remoteVersion);
                    if (_versionCheckTimer) {
                        clearInterval(_versionCheckTimer);
                        _versionCheckTimer = null;
                    }
                }
            } catch (e) {
                // 6 小時內同 source 最多記 1 筆（v15.065 60s 去重對 30 分輪詢來不及 collapse）
                const now = Date.now();
                if (now - _lastVersionCheckErrorTs > 6 * 60 * 60 * 1000) {
                    _lastVersionCheckErrorTs = now;
                    try { _recordAppError('app_version_check', e); } catch(_) {}
                }
            }
        }

        function _showVersionUpdateToast(remoteVersion) {
            // id guard：避免重複產生
            if (document.getElementById('version-update-toast')) return;
            const t = document.createElement('div');
            t.id = 'version-update-toast';
            t.style.cssText = 'position:fixed;top:1rem;left:50%;transform:translateX(-50%);z-index:99999;'
                + 'background:linear-gradient(135deg,#3b82f6,#2563eb);color:#fff;padding:0.75rem 1.25rem;'
                + 'border-radius:8px;font-weight:600;font-size:0.85rem;box-shadow:0 4px 12px rgba(0,0,0,0.4);cursor:pointer;';
            t.textContent = '⚡ 發現新版本 ' + remoteVersion + '，點此重新載入';
            t.onclick = () => location.reload();
            document.body.appendChild(t);
            // 不自動消失 — 等使用者點擊
        }

        function _recordAppError(source, err, meta) {
            try {
                const entry = {
                    ts: new Date().toISOString(),
                    source: String(source || 'unknown'),
                    status: (err?.status ?? null),
                    message: ((err?.message || String(err)) + '').slice(0, 500),
                    meta: meta || null,
                    count: 1
                };
                let log = [];
                try { log = JSON.parse(localStorage.getItem(STORAGE_KEYS.errorLog) || '[]'); } catch(_) {}
                if (!Array.isArray(log)) log = [];
                // v15.065：同 source + message 在 60s 內不新增，僅更新最後一筆的 ts 與 count
                if (log.length > 0) {
                    const last = log[log.length - 1];
                    if (last && last.source === entry.source && last.message === entry.message
                        && (Date.now() - new Date(last.ts).getTime()) < 60000) {
                        last.ts = entry.ts;
                        last.count = (last.count || 1) + 1;
                        localStorage.setItem(STORAGE_KEYS.errorLog, JSON.stringify(log));
                        _renderErrorLogCount();
                        return;
                    }
                }
                log.push(entry);
                if (log.length > 50) log = log.slice(-50);
                localStorage.setItem(STORAGE_KEYS.errorLog, JSON.stringify(log));
                _renderErrorLogCount();
            } catch(_) {}
        }
        function _renderErrorLogCount() {
            const el = document.getElementById('error-log-count');
            if (!el) return;
            let log = [];
            try { log = JSON.parse(localStorage.getItem(STORAGE_KEYS.errorLog) || '[]'); } catch(_) {}
            el.textContent = Array.isArray(log) ? log.length : 0;
        }
        function toggleErrorLog() {
            const pre = document.getElementById('error-log-display');
            if (!pre) return;
            if (pre.style.display === 'none' || !pre.style.display) {
                let log = [];
                try { log = JSON.parse(localStorage.getItem(STORAGE_KEYS.errorLog) || '[]'); } catch(_) {}
                if (!Array.isArray(log) || log.length === 0) {
                    pre.textContent = '（目前沒有錯誤紀錄）';
                } else {
                    const lines = log.slice().reverse().map(e =>
                        '[' + e.ts + '] ' + e.source +
                        (e.status ? ' (HTTP ' + e.status + ')' : '') +
                        (e.count > 1 ? ' × ' + e.count : '') +    // v15.065：去重後顯示重複次數
                        '\n  ' + e.message +
                        (e.meta ? '\n  meta: ' + JSON.stringify(e.meta) : '')
                    );
                    pre.textContent = lines.join('\n\n');
                }
                pre.style.display = 'block';
            } else {
                pre.style.display = 'none';
            }
        }
        function clearErrorLog() {
            if (!confirm('確認清除所有錯誤紀錄？')) return;
            localStorage.removeItem(STORAGE_KEYS.errorLog);
            _renderErrorLogCount();
            const pre = document.getElementById('error-log-display');
            if (pre) { pre.textContent = ''; pre.style.display = 'none'; }
            if (typeof showImportToast === 'function') showImportToast('✅ 錯誤紀錄已清除', 1500);
        }
        // v15.076：複製錯誤日誌 JSON 到剪貼簿（給 codex review / debug 用，省去截圖）
        function _copyErrorLog() {
            let log = [];
            try { log = JSON.parse(localStorage.getItem(STORAGE_KEYS.errorLog) || '[]'); } catch(_) {}
            if (!Array.isArray(log) || log.length === 0) {
                showImportToast('（目前沒有錯誤紀錄可複製）', 1500);
                return;
            }
            const text = JSON.stringify(log, null, 2);
            if (navigator.clipboard && navigator.clipboard.writeText) {
                navigator.clipboard.writeText(text)
                    .then(() => showImportToast(`已複製 ${log.length} 筆錯誤到剪貼簿`, 1500))
                    .catch(() => showImportToast('複製失敗（瀏覽器拒絕）', 2000));
            } else {
                showImportToast('複製失敗（瀏覽器不支援 Clipboard API）', 2000);
            }
        }

        // v15.061：記錄最後一次推送錯誤至 localStorage（v15.062 加入 err.status 優先判斷；v15.064 連動 _recordAppError）
        function _recordPushError(err, statusOverride) {
            try {
                let status = (statusOverride !== undefined) ? statusOverride : (err?.status ?? null);
                if (status == null) {
                    const m = (err?.message || '').match(/HTTP\s+(\d+)/i);
                    status = m ? parseInt(m[1], 10) : null;
                }
                localStorage.setItem('pt_last_push_error', JSON.stringify({
                    ts: new Date().toISOString(),
                    status,
                    message: err?.message || String(err)
                }));
                // v15.064：同步寫入完整錯誤日誌
                _recordAppError('gist_push', err, { status });
            } catch(_) {}
        }
        // v15.061：判斷錯誤是否為 401/403（Token 失效或權限不足）
        // v15.062 修正：優先看 err.status；GitHub API 401 回 "Bad credentials" 不含 "HTTP 401"
        function _isAuthError(err) {
            if (err?.status === 401 || err?.status === 403) return true;
            const msg = (err?.message || '').toLowerCase();
            if (msg.includes('bad credentials')) return true;
            if (msg.includes('requires authentication')) return true;
            if (msg.includes('must authenticate')) return true;
            const m = msg.match(/http\s+(\d+)/);
            if (!m) return false;
            const code = parseInt(m[1], 10);
            return code === 401 || code === 403;
        }
        // v15.061：401/403 路徑共用處理 — 強制停止 retry + toast
        function _handleAuthFailure() {
            _pushRetryCount = MAX_PUSH_RETRY;
            clearTimeout(_retryTimer);
            showWarnToast('❌ Gist Token 失效或權限不足，請至設定重新填入 Token', 8000);
        }

        function _scheduleRetry() {
            if (_pushRetryCount >= MAX_PUSH_RETRY) {
                console.warn('[AutoPush] 已達最大重試次數，等 online 事件或頁面重整或點擊 UI 提示再試');
                showWarnToast('⚠️ 同步失敗已達 5 次，請檢查網路或 Gist Token，可手動點擊左上角同步提示重試', 8000);
                return;
            }
            const delay = Math.min(1000 * Math.pow(2, _pushRetryCount), 30000);
            _pushRetryCount++;
            clearTimeout(_retryTimer);
            console.warn(`[AutoPush] 將在 ${delay}ms 後重試（第 ${_pushRetryCount}/${MAX_PUSH_RETRY} 次）`);
            _retryTimer = setTimeout(_gistSilentPush, delay);
        }

        // 網路恢復時自動重試
        window.addEventListener('online', () => {
            if (parseInt(localStorage.getItem(PT_PENDING_PUSH_COUNT) || '0', 10) > 0) {
                _pushRetryCount = 0;
                console.log('[AutoPush] 偵測到網路恢復，立即重試推送');
                _gistSilentPush();
            }
        });

        // 靜默推送 Gist（從 localStorage 讀憑證，無 UI 反饋，無 Token 則略過）
        async function _gistSilentPush() {
            const token  = localStorage.getItem(GIST_TOKEN_KEY);
            const gistId = localStorage.getItem(GIST_ID_KEY);
            if (!token || !gistId) return false; // 未設定憑證，只存 localStorage
            try {
                const _pf = await _preflightGistPush(token, gistId);
                if (_pf.action === 'reject') return false;
                // v15.079：hash_match → 內容無變化，不必 PATCH，只更 baseline + 清 dirty
                if (_pf.action === 'noop') {
                    _applySyncBaseline({
                        data: _pf.state.data,
                        saved: _pf.state.saved,
                        cloudRevision: _pf.state.cloudRevision,
                        cloudUpdatedAt: _pf.state.cloudUpdatedAt
                    }, { userDataHash: _pf.localHash });
                    _pushRetryCount = 0;
                    clearTimeout(_retryTimer);
                    _updateSyncTimeLabels();
                    localStorage.removeItem('pt_last_push_error');
                    console.log('[Snapshot] hash_match：本機與雲端內容相同，跳過 PATCH');
                    return true;
                }
                const pushedAt = new Date().toISOString();
                // v15.079：sync_meta 含 userDataHash；silent push 永不寫 master flag
                const sync_meta = await _buildSyncMeta(pushedAt, undefined, { userDataHash: _pf.localHash });
                const payload = JSON.stringify({
                    schema_version: PT_SCHEMA_VERSION,
                    holdings,
                    watchlist,
                    tradeHistory,
                    currency,
                    exchangeRates,
                    sheet_url:     document.getElementById('sheet-url')?.value?.trim() || '',
                    deposits,
                    cash_pie_cb:   document.getElementById('cash-pie-cb')?.checked  || false,
                    crypto_twd:    parseFloat(document.getElementById('crypto-twd-input')?.value) || 0,
                    crypto_pie_cb: document.getElementById('crypto-pie-cb')?.checked || false,
                    moxa_twd:      parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0,
                    moxa_pie_cb:   document.getElementById('moxa-pie-cb')?.checked   || false,
                    marketSnapshots,
                    daily_pnl_snapshots: _loadDailyPnlSnapshots(),   // v15.071：跨裝置同步
                    pushedAt,
                    sync_meta
                }, null, 2);
                const res = await fetch(`https://api.github.com/gists/${gistId}`, {
                    method: 'PATCH',
                    headers: {
                        'Authorization': `token ${token}`,
                        'Content-Type': 'application/json',
                        'Accept': 'application/vnd.github.v3+json'
                    },
                    body: JSON.stringify({
                        description: 'Portfolio Tracker 持倉同步',
                        public: false,
                        files: { [GIST_FILENAME]: { content: payload } }
                    })
                });
                if (!res.ok) {
                    const e = new Error(`HTTP ${res.status}`);
                    e.status = res.status;   // v15.062：保留 HTTP status
                    throw e;
                }
                const data = await res.json().catch(() => null);
                // v15.075/079：用 _applySyncBaseline 統一寫 baseline + 清 dirty + 清 pending + 寫 lastUserDataHash
                _applySyncBaseline(
                    { data, saved: null, cloudRevision: _gistRevision(data), cloudUpdatedAt: data?.updated_at || pushedAt },
                    { userDataHash: _pf.localHash }
                );
                _pushRetryCount = 0;
                clearTimeout(_retryTimer);
                _updateSyncTimeLabels();
                localStorage.removeItem('pt_last_push_error');
                console.log('[Snapshot] 快照已靜默同步至 Gist');
                return true;
            } catch(e) {
                console.warn('[Snapshot] 靜默推送失敗：', e.message);
                _recordPushError(e);
                if (_isAuthError(e)) {
                    _handleAuthFailure();
                    return false;
                }
                _scheduleRetry();
                return false;
            }
        }

        // 每日首次開啟時自動記錄市值快照
        // v15.079：snapshot 不再直接 _gistSilentPush()；marketSnapshots 不入 userDataHash，
        // 靠其他 domain push 順帶帶上雲端，pending count 不再因 snapshot-only 變動而 +1
        function recordSnapshot() {
            const today = new Date().toISOString().slice(0, 10);
            if (marketSnapshots.some(s => s.date === today)) return;
            const stockTWD = _currentStockValueTWD();
            if (stockTWD <= 0) return;
            marketSnapshots.push({ date: today, stockTWD });
            marketSnapshots.sort((a, b) => a.date.localeCompare(b.date));
            saveSnapshots();
        }

        // 依 mode 將快照分組，回傳 [{ key, first, last }] 降冪（快照為主）
        function _snapshotPeriods(mode) {
            if (!marketSnapshots.length) return [];
            const map = {};
            marketSnapshots.forEach(s => {
                let key;
                if (mode === 'month') key = s.date.slice(0, 7);
                else if (mode === 'quarter') {
                    const q = Math.ceil(parseInt(s.date.slice(5, 7)) / 3);
                    key = s.date.slice(0, 4) + '-Q' + q;
                } else key = s.date.slice(0, 4);
                if (!map[key]) map[key] = [];
                map[key].push(s);
            });
            return Object.entries(map)
                .map(([key, snaps]) => ({ key, first: snaps[0], last: snaps[snaps.length - 1] }))
                .sort((a, b) => b.key.localeCompare(a.key));
        }

        // 計算某 period key 的已實現損益（TWD）
        function _realizedInPeriod(key, mode) {
            let total = 0;
            tradeHistory.forEach(t => {
                const d = (t.date || '').slice(0, 10);
                if (!d) return;
                let tKey;
                if (mode === 'month') tKey = d.slice(0, 7);
                else if (mode === 'quarter') {
                    const q = Math.ceil(parseInt(d.slice(5, 7)) / 3);
                    tKey = d.slice(0, 4) + '-Q' + q;
                } else tKey = d.slice(0, 4);
                if (tKey === key) {
                    const fx = t.market === 'TW' ? 1 : t.market === 'HK' ? exchangeRates.HKD_TWD : exchangeRates.USD_TWD;
                    total += (t.realizedPL || 0) * fx;
                }
            });
            return total;
        }

        function renderReturnAnalysis() {
            const container = document.getElementById('return-analysis-section');
            if (!container) return;

            const fmtPct = (n) => (n >= 0 ? '+' : '') + (n * 100).toFixed(2) + '%';
            const fmtTWD = (n) => (n >= 0 ? '+' : '-') + 'NT$' + Math.abs(Math.round(n)).toLocaleString('en-US');
            const fmtAbs = (n) => 'NT$' + Math.round(n).toLocaleString('en-US');
            const clr    = (n) => n >= 0 ? '#10b981' : '#ef4444';

            const modeBtnStyle = (m) => {
                const active = _returnMode === m;
                return `padding:0.28rem 0.7rem;border-radius:6px;font-size:0.75rem;font-weight:600;cursor:pointer;text-transform:none;letter-spacing:0;border:1.5px solid ${active ? 'rgba(96,165,250,0.5)' : 'rgba(56,139,253,0.2)'};background:${active ? 'rgba(56,139,253,0.15)' : 'transparent'};color:${active ? '#60a5fa' : '#7e93a6'};`;
            };

            const periods = _snapshotPeriods(_returnMode);
            let rowsHtml = '';
            if (!periods.length) {
                rowsHtml = `<tr><td colspan="5" style="text-align:center;color:#607585;padding:1.5rem 0;font-size:0.85rem;">尚無快照資料，每日開啟後將自動累積</td></tr>`;
            } else {
                periods.forEach(p => {
                    const startVal  = p.first.stockTWD;
                    const endVal    = p.last.stockTWD;
                    const diff      = endVal - startVal;
                    const pct       = startVal > 0 ? diff / startVal : null;
                    const isSameDay = p.first.date === p.last.date;
                    const realized  = _realizedInPeriod(p.key, _returnMode);

                    rowsHtml += `
                    <tr style="border-bottom:1px solid rgba(255,255,255,0.04);">
                        <td style="padding:0.55rem 0.75rem;color:#e2e8f0;font-weight:600;font-size:0.85rem;">${p.key}</td>
                        <td style="padding:0.55rem 0.75rem;text-align:right;" class="mono">
                            <span style="color:#a8bdd0;font-size:0.82rem;">${pv(fmtAbs(startVal))}</span>
                            <div style="color:#607585;font-size:0.68rem;">${p.first.date}</div>
                        </td>
                        <td style="padding:0.55rem 0.75rem;text-align:right;" class="mono">
                            <span style="color:#a8bdd0;font-size:0.82rem;">${pv(fmtAbs(endVal))}</span>
                            <div style="color:#607585;font-size:0.68rem;">${p.last.date}</div>
                        </td>
                        <td style="padding:0.55rem 0.75rem;text-align:right;" class="mono">
                            ${isSameDay
                                ? '<span style="color:#607585;font-size:0.73rem;">單日資料</span>'
                                : pct != null
                                    ? `<span style="color:${clr(pct)};font-weight:700;font-size:0.92rem;">${pv(fmtPct(pct))}</span>
                                       <div style="color:${clr(diff)};font-size:0.71rem;">${pv(fmtTWD(diff))}</div>`
                                    : '<span style="color:#607585">—</span>'
                            }
                        </td>
                        <td style="padding:0.55rem 0.75rem;text-align:right;" class="mono">
                            ${realized !== 0
                                ? `<span style="color:${clr(realized)};font-weight:600;font-size:0.82rem;">${pv(fmtTWD(realized))}</span>`
                                : '<span style="color:#607585;font-size:0.78rem;">—</span>'
                            }
                        </td>
                    </tr>`;
                });
            }

            const snCount = marketSnapshots.length;
            const snNote  = snCount === 0
                ? '每日開啟時將自動記錄市值，累積後可計算各期間報酬'
                : `已累積 ${snCount} 筆每日快照`;

            container.innerHTML = `
            <div class="glass-card" style="margin-top:0.75rem;">
                <div style="padding:1rem 1.25rem 0.75rem;display:flex;align-items:center;justify-content:space-between;flex-wrap:wrap;gap:0.5rem;border-bottom:1px solid rgba(255,255,255,0.06);">
                    <div>
                        <span style="color:#f1f5f9;font-weight:600;font-size:0.9rem;margin-right:0.6rem;">◈ 期間資產報酬</span>
                        <span style="color:#607585;font-size:0.73rem;">${snNote}</span>
                    </div>
                    <div style="display:flex;gap:0.35rem;">
                        <button onclick="_returnMode='month';renderReturnAnalysis();" style="${modeBtnStyle('month')}">月</button>
                        <button onclick="_returnMode='quarter';renderReturnAnalysis();" style="${modeBtnStyle('quarter')}">季</button>
                        <button onclick="_returnMode='year';renderReturnAnalysis();" style="${modeBtnStyle('year')}">年</button>
                    </div>
                </div>
                <div style="overflow-x:auto;">
                    <table style="width:100%;border-collapse:collapse;">
                        <thead>
                            <tr style="border-bottom:1px solid rgba(255,255,255,0.08);">
                                <th style="padding:0.45rem 0.75rem;color:#607585;font-size:0.71rem;font-weight:600;text-align:left;white-space:nowrap;">期間</th>
                                <th style="padding:0.45rem 0.75rem;color:#607585;font-size:0.71rem;font-weight:600;text-align:right;white-space:nowrap;">期初市值</th>
                                <th style="padding:0.45rem 0.75rem;color:#607585;font-size:0.71rem;font-weight:600;text-align:right;white-space:nowrap;">期末市值</th>
                                <th style="padding:0.45rem 0.75rem;color:#607585;font-size:0.71rem;font-weight:600;text-align:right;white-space:nowrap;">漲跌幅<span style="color:#475569;font-size:0.67rem;margin-left:0.2rem;">含未實現</span></th>
                                <th style="padding:0.45rem 0.75rem;color:#607585;font-size:0.71rem;font-weight:600;text-align:right;white-space:nowrap;">已實現損益</th>
                            </tr>
                        </thead>
                        <tbody>${rowsHtml}</tbody>
                    </table>
                </div>
            </div>`;
        }

        // 確保 holding 有 lots 欄位（舊資料向下相容）
        function _ensureLots(h) {
            if (!h.lots || !Array.isArray(h.lots) || h.lots.length === 0) {
                h.lots = [{ qty: h.quantity, cost: h.costPrice, date: h.addedDate || new Date().toISOString() }];
            }
        }
        // 手動修改數量/成本時，將 lots 重設為單一批次（保持一致性）
        function _resetLots(h) {
            h.lots = [{ qty: h.quantity, cost: h.costPrice, date: new Date().toISOString() }];
        }
        function clearTradeHistory() {
            if (!confirm('確定清除所有已實現損益紀錄？此操作無法復原。')) return;
            tradeHistory = [];
            saveTradeHistory();
            _markAndAutoPush(['tradeHistory']);
            renderRealizedTab();
        }
        function _setRealizedPreset(val) {
            const today = new Date();
            let from = '';
            if (val === '7d')  { from = new Date(today - 7*86400000); }
            else if (val === '1m')  { from = new Date(today); from.setMonth(from.getMonth()-1); }
            else if (val === '3m')  { from = new Date(today); from.setMonth(from.getMonth()-3); }
            else if (val === '1y')  { from = new Date(today); from.setFullYear(from.getFullYear()-1); }
            else if (val === '3y')  { from = new Date(today); from.setFullYear(from.getFullYear()-3); }
            else if (val === '5y')  { from = new Date(today); from.setFullYear(from.getFullYear()-5); }
            else { _realizedDateFrom = ''; _realizedDateTo = ''; renderRealizedTab(); return; }
            _realizedDateFrom = from.toISOString().slice(0,10);
            _realizedDateTo   = today.toISOString().slice(0,10);
            renderRealizedTab();
        }
        function _setRealizedDateRange() {
            _realizedDateFrom = document.getElementById('realized-from')?.value || '';
            _realizedDateTo   = document.getElementById('realized-to')?.value   || '';
            // 重設下拉選單
            const sel = document.getElementById('realized-preset');
            if (sel) sel.value = '';
            renderRealizedTab();
        }
        function _toggleRealizedCcy() {
            _realizedCurrency = _realizedCurrency === 'native' ? 'TWD' : 'native';
            renderRealizedTab();
        }
        function renderRealizedTab() {
            const pane = document.getElementById('tab-pane-6');
            if (!pane) return;
            if (tradeHistory.length === 0) {
                pane.innerHTML = `<div class="glass-card" style="padding:2.5rem 2rem; text-align:center; margin-top:0.5rem;">
                    <div style="font-size:2.2rem; color:#1e3a5f; margin-bottom:0.75rem;">◈</div>
                    <div style="color:#7e93a6; font-size:0.95rem; font-weight:600;">尚無已實現損益紀錄</div>
                    <div style="color:#607585; font-size:0.82rem; margin-top:0.35rem;">完成賣出交易後將自動記錄於此</div>
                </div><div id="return-analysis-section"></div>`;
                renderReturnAnalysis();
                return;
            }
            // ── 日期篩選 ──
            const fromTs = _realizedDateFrom ? new Date(_realizedDateFrom + 'T00:00:00').getTime() : 0;
            const toTs   = _realizedDateTo   ? new Date(_realizedDateTo   + 'T23:59:59').getTime() : Infinity;
            const filtered = tradeHistory.filter(t => {
                const ts = new Date(t.date).getTime();
                return ts >= fromTs && ts <= toTs;
            });
            const showTWD = _realizedCurrency === 'TWD';
            const _fxRate = (market) => market === 'TW' ? 1 : market === 'HK' ? exchangeRates.HKD_TWD : exchangeRates.USD_TWD;
            // ── 彙整：依標的分組 ──
            const bySymbol = {};
            [...filtered].reverse().forEach(t => {
                if (!bySymbol[t.symbol]) bySymbol[t.symbol] = { symbol: t.symbol, market: t.market || 'US', trades: [], totalPL: 0 };
                bySymbol[t.symbol].trades.push(t);
                bySymbol[t.symbol].totalPL += t.realizedPL;
            });
            // ── 加總 ──
            let totUS = 0, totTW = 0, totHK = 0;
            Object.values(bySymbol).forEach(s => {
                if (s.market === 'TW') totTW += s.totalPL;
                else if (s.market === 'HK') totHK += s.totalPL;
                else totUS += s.totalPL;
            });
            const totTWD = totUS * exchangeRates.USD_TWD + totTW + totHK * exchangeRates.HKD_TWD;
            const totColor = totTWD >= 0 ? '#10b981' : '#ef4444';
            const fmt2 = (n) => Math.abs(n).toLocaleString('en-US', {minimumFractionDigits:2, maximumFractionDigits:2});
            const fmtSign = (n) => n >= 0 ? '+' : '-';
            // ── 總計卡片（標題 → 累計 → 篩選列）──
            const ccyBtnBg  = showTWD ? 'rgba(16,185,129,0.15)' : 'rgba(30,58,110,0.2)';
            const ccyBtnClr = showTWD ? '#10b981' : '#60a5fa';
            const ccyBtnBdr = showTWD ? 'rgba(16,185,129,0.35)' : 'rgba(56,139,253,0.25)';
            const inpStyle  = 'width:118px;padding:0.32rem 0.4rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.22);border-radius:7px;color:#a8bdd0;font-size:0.75rem;outline:none;';
            const lblStyle  = 'color:#7e93a6;font-size:0.75rem;white-space:nowrap;';
            const summaryHtml = `
            <div class="glass-card" style="padding:1.25rem 1.5rem; margin-bottom:1rem;">
                <!-- 標題列 -->
                <div style="display:flex; align-items:center; justify-content:space-between; margin-bottom:0.9rem;">
                    <h2 style="color:#f1f5f9; font-size:1.1rem; font-weight:600; margin:0;"><i class="ic">◈</i> 已實現損益紀錄</h2>
                    <div style="display:flex;gap:0.45rem;align-items:center;">
                        ${_pvBtnHtml()}
                        <button onclick="clearTradeHistory()" style="padding:0.32rem 0.7rem;background:rgba(239,68,68,0.1);border:1px solid rgba(239,68,68,0.28);border-radius:8px;color:#f87171;font-size:0.76rem;font-weight:600;cursor:pointer;text-transform:none;letter-spacing:0;">清除紀錄</button>
                    </div>
                </div>
                <!-- 累計損益（標題正下方） -->
                <div style="display:flex; gap:2rem; flex-wrap:wrap; align-items:flex-end; padding-bottom:0.9rem; margin-bottom:0.75rem; border-bottom:1px solid rgba(255,255,255,0.06);">
                    <div>
                        <div style="color:#7e93a6; font-size:0.72rem; margin-bottom:0.25rem; letter-spacing:0.04em;">累計已實現${showTWD ? '（TWD）' : '（約合 TWD）'}</div>
                        <div class="mono" style="font-size:1.9rem; font-weight:800; color:${totColor}; line-height:1;">${pv(`${fmtSign(totTWD)}NT$${Math.abs(Math.round(totTWD)).toLocaleString('en-US')}`)}</div>
                    </div>
                    ${!showTWD && totUS !== 0 ? `<div><div style="color:#7e93a6;font-size:0.71rem;margin-bottom:0.18rem;">美股 USD</div><div class="mono" style="font-size:0.93rem;font-weight:700;color:${totUS>=0?'#10b981':'#ef4444'};">${pv(`${fmtSign(totUS)}$${fmt2(totUS)}`)}</div></div>` : ''}
                    ${!showTWD && totTW !== 0 ? `<div><div style="color:#7e93a6;font-size:0.71rem;margin-bottom:0.18rem;">台股 TWD</div><div class="mono" style="font-size:0.93rem;font-weight:700;color:${totTW>=0?'#10b981':'#ef4444'};">${pv(`${fmtSign(totTW)}NT$${fmt2(totTW)}`)}</div></div>` : ''}
                    ${!showTWD && totHK !== 0 ? `<div><div style="color:#7e93a6;font-size:0.71rem;margin-bottom:0.18rem;">港股 HKD</div><div class="mono" style="font-size:0.93rem;font-weight:700;color:${totHK>=0?'#10b981':'#ef4444'};">${pv(`${fmtSign(totHK)}HK$${fmt2(totHK)}`)}</div></div>` : ''}
                </div>
                <!-- 篩選列：桌機一行，手機自動換兩行 -->
                <div style="display:flex; gap:0.5rem 0.75rem; align-items:center; flex-wrap:wrap;">
                    <!-- 第一群：日期區間 -->
                    <div style="display:flex; gap:0.4rem; align-items:center; flex-shrink:0;">
                        <span style="${lblStyle}">開始</span>
                        <input id="realized-from" type="date" value="${_realizedDateFrom}" onchange="_setRealizedDateRange()" style="${inpStyle}">
                        <span style="${lblStyle}">結束</span>
                        <input id="realized-to" type="date" value="${_realizedDateTo}" onchange="_setRealizedDateRange()" style="${inpStyle}">
                    </div>
                    <!-- 第二群：快捷＋幣別＋筆數 -->
                    <div style="display:flex; gap:0.4rem; align-items:center; flex-shrink:0;">
                        <select id="realized-preset" onchange="_setRealizedPreset(this.value)" style="width:auto;padding:0.32rem 0.45rem;background:rgba(6,13,26,0.9);border:1.5px solid rgba(56,139,253,0.22);border-radius:7px;color:#a8bdd0;font-size:0.75rem;outline:none;cursor:pointer;">
                            <option value="">全部</option>
                            <option value="7d">過去 7 天</option>
                            <option value="1m">過去 1 月</option>
                            <option value="3m">過去 1 季</option>
                            <option value="1y">過去 1 年</option>
                            <option value="3y">過去 3 年</option>
                            <option value="5y">過去 5 年</option>
                        </select>
                        <button onclick="_toggleRealizedCcy()" style="padding:0.32rem 0.65rem;background:${ccyBtnBg};border:1.5px solid ${ccyBtnBdr};border-radius:7px;color:${ccyBtnClr};font-size:0.78rem;font-weight:700;cursor:pointer;text-transform:none;letter-spacing:0;">${showTWD ? 'NT$ 台幣' : '原幣'}</button>
                        <span style="color:#7e93a6;font-size:0.78rem;">交易 <span style="color:#a8bdd0;font-weight:700;">${filtered.length}</span> 筆</span>
                    </div>
                </div>
            </div>`;
            // ── 標的卡片 ──
            const symbolsHtml = Object.values(bySymbol).map(s => {
                const nativeCcy = s.market === 'TW' ? 'NT$' : s.market === 'HK' ? 'HK$' : '$';
                const dispCcy   = showTWD ? 'NT$' : nativeCcy;
                const fx        = showTWD ? _fxRate(s.market) : 1;
                const dispPL    = s.totalPL * fx;
                const isPos     = dispPL >= 0;
                const color     = isPos ? '#10b981' : '#ef4444';
                const flag      = s.market === 'TW' ? '🇹🇼' : s.market === 'HK' ? '🇭🇰' : '🇺🇸';
                const expd      = _realizedExpanded[s.symbol] || false;
                const tradesHtml = s.trades.map(t => {
                    const d  = new Date(t.date);
                    const ds = isNaN(d) ? t.date : d.toLocaleDateString('zh-TW', {year:'numeric',month:'2-digit',day:'2-digit'});
                    const tPL = t.realizedPL * fx;
                    const tP  = tPL >= 0;
                    const lotsDesc = (t.lotsConsumed||[]).map(l => `${parseFloat(l.qty.toFixed(4))}@${nativeCcy}${parseFloat(l.cost.toFixed(4))}`).join(' + ') || '-';
                    return `<div style="display:grid;grid-template-columns:90px 1fr 1fr 1fr auto;gap:0.35rem 0.65rem;align-items:center;padding:0.42rem 0;border-bottom:1px solid rgba(255,255,255,0.04);font-size:0.79rem;">
                        <span style="color:#7e93a6;">${ds}</span>
                        <span style="color:#e2e8f0;">賣 ${parseFloat(t.qty.toFixed(4)).toLocaleString('en-US',{maximumFractionDigits:4})} 股</span>
                        <span style="color:#60a5fa;">${nativeCcy}${parseFloat(t.price.toFixed(4))} / 股</span>
                        <span style="color:#607585;font-size:0.72rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;" title="${lotsDesc}">${lotsDesc}</span>
                        <span class="mono" style="font-weight:700;color:${tP?'#10b981':'#ef4444'};text-align:right;">${pv(`${fmtSign(tPL)}${dispCcy}${fmt2(tPL)}`)}</span>
                    </div>`;
                }).join('');
                return `
                <div class="glass-card" style="padding:0; margin-bottom:0.45rem; overflow:hidden;">
                    <div onclick="_realizedExpanded['${s.symbol}']=!(_realizedExpanded['${s.symbol}']||false);renderRealizedTab();" style="display:flex;align-items:center;justify-content:space-between;padding:0.7rem 1.25rem;cursor:pointer;transition:background 0.15s;" onmouseover="this.style.background='rgba(56,139,253,0.05)'" onmouseout="this.style.background=''">
                        <div style="display:flex;align-items:center;gap:0.6rem;">
                            <span class="market-badge">${flag} ${s.market}</span>
                            <span class="mono" style="color:#f1f5f9;font-size:0.95rem;font-weight:700;">${s.symbol}</span>
                            <span style="color:#7e93a6;font-size:0.76rem;">${s.trades.length} 筆</span>
                        </div>
                        <div style="display:flex;align-items:center;gap:0.75rem;">
                            <span class="mono" style="font-weight:700;font-size:0.98rem;color:${color};">${pv(`${fmtSign(dispPL)}${dispCcy}${fmt2(dispPL)}`)}</span>
                            <span style="color:#7e93a6;font-size:0.78rem;">${expd?'▲':'▶'}</span>
                        </div>
                    </div>
                    ${expd ? `<div style="padding:0.4rem 1.25rem 0.85rem;border-top:1px solid rgba(255,255,255,0.06);background:rgba(6,13,26,0.35);">
                        <div style="display:grid;grid-template-columns:90px 1fr 1fr 1fr auto;gap:0.2rem 0.65rem;padding:0.28rem 0;border-bottom:1px solid rgba(255,255,255,0.08);font-size:0.71rem;color:#607585;margin-bottom:0.15rem;">
                            <span>日期</span><span>數量</span><span>賣出價</span><span>成本批次</span><span style="text-align:right;">損益</span>
                        </div>
                        ${tradesHtml}
                    </div>` : ''}
                </div>`;
            }).join('');
            pane.innerHTML = summaryHtml + (filtered.length === 0 ? '<div style="text-align:center;padding:2rem;color:#607585;font-size:0.9rem;">此區間無交易紀錄</div>' : symbolsHtml) + '<div id="return-analysis-section"></div>';
            renderReturnAnalysis();
        }

        // 合併持倉 + 觀察清單（供分析管線使用）
        function _allAnalysisTargets() {
            const holdingSyms = new Set(holdings.map(h => h.symbol));
            const extras = watchlist
                .filter(w => !holdingSyms.has(w.symbol))
                .map(w => ({ symbol: w.symbol, market: w.market || 'US', currentPrice: 0, quantity: 0, _isWatchlist: true }));
            return [...holdings, ...extras];
        }

        // ==================== v13 LocalStorage 持久化 ====================
        const PT_STORAGE_KEY = 'pt_v13p_state';

        let _storageReady = false; // 初始化完成前不允許存檔

        // ── GitHub Gist 跨裝置同步 ──
        const GIST_TOKEN_KEY = 'pt_gist_token_v15';
        const GIST_ID_KEY    = 'pt_gist_id_v15';
        const GIST_FILENAME  = 'portfolio-tracker-holdings.json';

        function loadGistSettings() {
            const token = localStorage.getItem(GIST_TOKEN_KEY) || '';
            const id    = localStorage.getItem(GIST_ID_KEY)    || '';
            const tokenEl = document.getElementById('gist-token');
            const idEl    = document.getElementById('gist-id');
            if (tokenEl && token) tokenEl.value = token;
            if (idEl    && id)    idEl.value    = id;
        }

        function saveGistSettings(token, id) {
            if (token) localStorage.setItem(GIST_TOKEN_KEY, token);
            if (id)    localStorage.setItem(GIST_ID_KEY,    id);
        }

        function setGistStatus(msg, color) {
            const el = document.getElementById('gist-status');
            if (el) { el.textContent = msg; el.style.color = color || '#475569'; }
        }

        async function gistPush() {
            const token = document.getElementById('gist-token')?.value?.trim();
            const gistId = document.getElementById('gist-id')?.value?.trim();
            if (!token) { setGistStatus('❌ 請先填入 GitHub Token', '#ef4444'); showWarnToast('❌ 請先在設定填入 GitHub Token'); return; }
            if (holdings.length === 0 && deposits.length === 0) { setGistStatus('❌ 目前無資料可推送', '#ef4444'); showWarnToast('❌ 目前無持倉或存款資料可推送'); return; }

            // v15.079：手動推送先進三選一 modal（master / staging / cancel）
            const mode = await _promptPushMode();
            if (mode === 'cancel') { setGistStatus('已取消推送', '#fbbf24'); return; }

            setGistStatus('⏳ 推送中...', '#60a5fa');
            let _force = false;
            let _pf;
            try {
                _pf = await _preflightGistPush(token, gistId);
            } catch(e) {
                // v15.062：preflight 失敗時也要記錄錯誤、判斷 401/403 後停止重試
                _recordPushError(e);
                setGistStatus(`❌ 推送前檢查失敗：${e.message}`, '#ef4444');
                if (_isAuthError(e)) {
                    _handleAuthFailure();
                } else {
                    showWarnToast(`❌ 推送前檢查失敗：${e.message}`);
                }
                return;
            }

            // v15.079：staging + hash_match → 不送 PATCH，只更 baseline + 清 dirty
            if (mode === 'staging' && _pf.action === 'noop') {
                _applySyncBaseline(
                    { data: _pf.state.data, saved: _pf.state.saved, cloudRevision: _pf.state.cloudRevision, cloudUpdatedAt: _pf.state.cloudUpdatedAt },
                    { userDataHash: _pf.localHash }
                );
                _updateSyncTimeLabels();
                localStorage.removeItem('pt_last_push_error');
                const t0 = new Date().toLocaleTimeString('zh-TW');
                setGistStatus(`✅ 雲端與本機內容相同，已更新基準（${t0}）`, '#10b981');
                showImportToast('✅ 雲端與本機內容相同，已更新同步基準', 2500);
                return;
            }

            // v15.079：staging + reject → confirm 強制覆蓋逃生口（master 模式直接 force，不問）
            if (mode === 'staging' && _pf.action === 'reject') {
                const ok = confirm(
                    '雲端已有他裝置 push 過的較新資料，預設拒絕推送以避免覆蓋。\n\n' +
                    '若你確定本機資料才是正本（例如離線修改後回到網路），可選「確定」強制推送覆蓋雲端。\n' +
                    '取消後可改用「拉取雲端最新」按鈕。'
                );
                if (!ok) { setGistStatus('已取消推送', '#fbbf24'); return; }
                _force = true;
            }

            // v15.079：master 模式 — 總是 force 推（即使 preflight reject 也覆蓋），並寫 master flag + 存 IDB rollback
            let userConfirmedCloudMaster = null;
            if (mode === 'master') {
                _force = true;
                const masterId = (typeof crypto !== 'undefined' && crypto.randomUUID)
                    ? crypto.randomUUID()
                    : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
                const sourceDeviceId = _getDeviceId();
                userConfirmedCloudMaster = {
                    id: masterId,
                    at: '',                              // 下面 pushedAt 確定後再回填
                    userDataHash: _pf.localHash,
                    appVersion: APP_VERSION,
                    sourceDeviceId
                };
                // 標記前先存本機回復點（含當時雲端 payload 完整 dump）
                try {
                    const beforePayload = _pf.state?.saved || null;
                    let beforeHash = beforePayload?.sync_meta?.userDataHash || null;
                    if (!beforeHash && beforePayload) {
                        beforeHash = await _userDataHash(_extractUserDataFromGistPayload(beforePayload));
                    }
                    const createdAt = new Date().toISOString();
                    await _idbSaveRollback(masterId, {
                        masterId,
                        sourceDeviceId,
                        createdAt,
                        beforeCloudPayload: beforePayload,
                        beforeCloudUserDataHash: beforeHash,
                        afterUserDataHash: _pf.localHash
                    });
                    _saveRollbackSummary({ masterId, createdAt, sourceDeviceId });
                } catch(e) {
                    console.warn('[MasterPush] save rollback failed:', e);
                    showWarnToast('⚠ 無法建立本機回復點（IndexedDB 異常），仍會繼續推送', 4000);
                }
            }

            const pushedAt = new Date().toISOString();
            if (userConfirmedCloudMaster) userConfirmedCloudMaster.at = pushedAt;

            const sync_meta = await _buildSyncMeta(pushedAt, undefined, {
                userDataHash: _pf.localHash,
                userConfirmedCloudMaster
            });

            const payload = JSON.stringify({
                schema_version: PT_SCHEMA_VERSION,
                holdings,
                watchlist,
                tradeHistory,
                currency,
                exchangeRates,
                sheet_url:    document.getElementById('sheet-url')?.value?.trim() || '',
                deposits,
                cash_pie_cb:  document.getElementById('cash-pie-cb')?.checked  || false,
                crypto_twd:   parseFloat(document.getElementById('crypto-twd-input')?.value) || 0,
                crypto_pie_cb: document.getElementById('crypto-pie-cb')?.checked || false,
                moxa_twd:     parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0,
                moxa_pie_cb:  document.getElementById('moxa-pie-cb')?.checked   || false,
                marketSnapshots,
                daily_pnl_snapshots: _loadDailyPnlSnapshots(),   // v15.071：跨裝置同步
                pushedAt,
                sync_meta
            }, null, 2);

            try {
                let url, method;
                if (gistId) {
                    // 更新既有 Gist
                    url    = `https://api.github.com/gists/${gistId}`;
                    method = 'PATCH';
                } else {
                    // 首次建立 Gist
                    url    = 'https://api.github.com/gists';
                    method = 'POST';
                }

                const body = {
                    description: 'Portfolio Tracker 持倉同步',
                    public: false,
                    files: { [GIST_FILENAME]: { content: payload } }
                };

                const res = await fetch(url, {
                    method,
                    headers: {
                        'Authorization': `token ${token}`,
                        'Content-Type': 'application/json',
                        'Accept': 'application/vnd.github.v3+json'
                    },
                    body: JSON.stringify(body)
                });

                if (!res.ok) {
                    const err = await res.json().catch(() => ({}));
                    const e = new Error(err.message || `HTTP ${res.status}`);
                    e.status = res.status;   // v15.062：保留 HTTP status
                    throw e;
                }

                const data = await res.json();
                const newId = data.id;

                // 首次推送後自動填入 Gist ID
                if (!gistId) {
                    const idEl = document.getElementById('gist-id');
                    if (idEl) idEl.value = newId;
                }

                // 永遠記住 Token 和 Gist ID
                saveGistSettings(token, newId);
                // v15.075/079：_applySyncBaseline 統一寫 baseline + 清 dirty + 寫 lastUserDataHash
                _applySyncBaseline(
                    { data, saved: null, cloudRevision: _gistRevision(data), cloudUpdatedAt: data?.updated_at || pushedAt },
                    { userDataHash: _pf.localHash }
                );
                // master 模式：把自己這次的 master id 加入「已處理」清單，避免下次 silent pull 把自己又拉一次
                if (mode === 'master' && userConfirmedCloudMaster) {
                    _addProcessedMasterId(userConfirmedCloudMaster.id);
                }
                _updateSyncTimeLabels();
                localStorage.removeItem('pt_last_push_error');

                const t = new Date().toLocaleTimeString('zh-TW');
                const depNote = deposits.length > 0 ? ` + ${deposits.length} 筆存款` : '';
                const modeTag = mode === 'master' ? '（標記最新版）' : (_force ? '（強制覆蓋）' : '（暫存上傳）');
                setGistStatus(`✅ 已推送 ${holdings.length} 筆持倉${depNote}${modeTag}（${t}）`, '#10b981');
                showImportToast(`✅ 資料已推送至 GitHub Gist（持倉 ${holdings.length} 筆${depNote}）${modeTag}`, 2500);

            } catch(e) {
                _recordPushError(e);
                setGistStatus(`❌ 推送失敗：${e.message}`, '#ef4444');
                if (_isAuthError(e)) {
                    _handleAuthFailure();
                } else {
                    showWarnToast(`❌ 推送失敗：${e.message}`, 5000);
                }
            }
        }

        async function gistPull() {
            const token  = document.getElementById('gist-token')?.value?.trim();
            const gistId = document.getElementById('gist-id')?.value?.trim();
            if (!token)  { setGistStatus('❌ 請先填入 GitHub Token', '#ef4444'); return; }
            if (!gistId) { setGistStatus('❌ 請填入 Gist ID（先在其他裝置推送過一次）', '#ef4444'); return; }

            setGistStatus('⏳ 從雲端拉取中...', '#60a5fa');
            try {
                const gistState = await _fetchGistState(token, gistId);
                const saved = gistState.saved;
                if (!saved) throw new Error(`找不到 ${GIST_FILENAME} 檔案`);

                if (!Array.isArray(saved.holdings) || saved.holdings.length === 0)
                    throw new Error('雲端資料為空');

                // Schema 版本檢查：雲端比本機新時直接拒絕拉取，避免破壞性覆蓋
                const _savedSchema = saved.schema_version || 1;
                if (_savedSchema > PT_SCHEMA_VERSION) {
                    setGistStatus(`❌ Gist schema v${_savedSchema} 高於本機 v${PT_SCHEMA_VERSION}，請先更新 PWA`, '#ef4444');
                    showWarnToast(`❌ 雲端資料是較新版本（v${_savedSchema}）產生，請先更新 PWA 後再拉取`);
                    return;
                }

                const dirtyDomains = _getDirtyDomains();
                if (dirtyDomains.length > 0) {
                    const ok = confirm(`本機有尚未上傳的修改（${dirtyDomains.join(', ')}）。拉取雲端資料會覆蓋本機未上傳修改，確定要繼續？`);
                    if (!ok) {
                        setGistStatus('已取消拉取：本機仍有未上傳修改', '#fbbf24');
                        return;
                    }
                }

                // v15.075：手動 pull = 放棄本機未上傳異動，不再把 dirty 狀態存進 undo（結尾會清 history）
                _isApplyingCloudPull = true;
                holdings = saved.holdings;
                holdings.forEach(h => { h.persist = true; _ensureLots(h); }); // 從雲端拉取一律標記保留，並補齊 lots
                if (saved.currency)      currency = saved.currency;
                if (saved.exchangeRates) {
                    exchangeRates = saved.exchangeRates;
                    syncRateInputs();
                }
                // 還原 Google Sheet CSV 連結
                if (saved.sheet_url) {
                    const sheetEl = document.getElementById('sheet-url');
                    if (sheetEl) sheetEl.value = saved.sheet_url;
                    saveSheetUrlSetting();
                }

                // 還原存款資料
                deposits = Array.isArray(saved.deposits) ? saved.deposits : [];
                saveDeposits();
                if (saved.cash_pie_cb != null) {
                    localStorage.setItem(PT_CASH_PIE_KEY, saved.cash_pie_cb ? '1' : '0');
                    const cb = document.getElementById('cash-pie-cb');
                    if (cb) cb.checked = !!saved.cash_pie_cb;
                }
                // 還原加密部位
                if (saved.crypto_twd != null) {
                    const v = saved.crypto_twd || 0;
                    if (v > 0) localStorage.setItem(PT_CRYPTO_KEY, v); else localStorage.removeItem(PT_CRYPTO_KEY);
                    const el = document.getElementById('crypto-twd-input');
                    if (el) el.value = v > 0 ? v : '';
                }
                if (saved.crypto_pie_cb != null) {
                    localStorage.setItem(PT_CRYPTO_PIE_KEY, saved.crypto_pie_cb ? '1' : '0');
                    const cb = document.getElementById('crypto-pie-cb');
                    if (cb) cb.checked = !!saved.crypto_pie_cb;
                }
                // 還原 MOXA 部位
                if (saved.moxa_twd != null) {
                    const v = saved.moxa_twd || 0;
                    if (v > 0) localStorage.setItem(PT_MOXA_KEY, v); else localStorage.removeItem(PT_MOXA_KEY);
                    const el = document.getElementById('moxa-twd-input');
                    if (el) el.value = v > 0 ? v : '';
                }
                if (saved.moxa_pie_cb != null) {
                    localStorage.setItem(PT_MOXA_PIE_KEY, saved.moxa_pie_cb ? '1' : '0');
                    const cb = document.getElementById('moxa-pie-cb');
                    if (cb) cb.checked = !!saved.moxa_pie_cb;
                }

                // 還原觀察清單
                if (Array.isArray(saved.watchlist)) {
                    watchlist = saved.watchlist;
                    saveWatchlist();
                    renderWatchlist();
                }
                // 還原已實現損益紀錄（永遠以雲端為準，無資料則清空）
                tradeHistory = Array.isArray(saved.tradeHistory) ? saved.tradeHistory : [];
                saveTradeHistory();
                // 還原市值快照
                if (Array.isArray(saved.marketSnapshots)) { marketSnapshots = saved.marketSnapshots; saveSnapshots(); }
                // 永遠記住 Token 和 Gist ID
                saveGistSettings(token, gistId);
                // v15.075/079：統一寫 baseline + 清 dirty；同時計算 hash 寫 lastUserDataHash + 標 master 處理（如有）
                let _pulledHash = saved?.sync_meta?.userDataHash || null;
                if (!_pulledHash) {
                    try { _pulledHash = await _userDataHash(_extractUserDataFromGistPayload(saved)); } catch(_) {}
                }
                // v15.071/080：merge 雲端 daily_pnl_snapshots 進本機（傳本機 hash 給 priority 用）
                try {
                    if (saved.daily_pnl_snapshots && saved.daily_pnl_snapshots.markets) {
                        const merged = _mergeDailyPnlSnapshots(_loadDailyPnlSnapshots(), saved.daily_pnl_snapshots, _pulledHash);
                        _saveDailyPnlSnapshots(merged);
                    }
                } catch(_) {}
                // v15.080：手動 pull 也套用 system data（baselines / price_cache）+ hydrate _prevCloseCache
                try { _applySystemDataFromPayload(saved); } catch(_) {}
                _applySyncBaseline(gistState, { userDataHash: _pulledHash });
                try {
                    const mf = saved?.sync_meta?.userConfirmedCloudMaster;
                    if (mf && mf.id) _addProcessedMasterId(mf.id);
                } catch(_) {}
                _storageReady = true;
                saveToStorage();

                // v15.075：手動 pull = 放棄本機未上傳異動 → 完整 reset，避免下次重啟又被 dirty 卡住
                history = [];
                _redoStack = [];
                _syncUndoRedoBtns();
                localStorage.removeItem(PT_LOCAL_MODIFY_TS);
                clearTimeout(_autoPushTimer);
                clearTimeout(_retryTimer);
                _pushRetryCount = 0;

                renderAll();
                // v15.080 hotfix P2：與 silent pull 對齊的後處理 — hydrate cache + 1.5s 後背景跑 loadAnalysis +
                // 8s 後若 baselines 仍空就 backfill（避免新瀏覽器 manual pull 後今日損益卡住直到下小時 timer）
                try { _hydrateDailyPnlCachesFromAnalysisCache(); } catch(_) {}
                try {
                    if (typeof loadAnalysis === 'function' && holdings.length > 0) {
                        setTimeout(() => loadAnalysis(false, true), 1500);
                    }
                } catch(_) {}
                setTimeout(() => {
                    try {
                        if (Array.isArray(holdings) && holdings.length > 0) {
                            const hasBaseline = _dailyPnlBaselines && _dailyPnlBaselines.symbols && Object.keys(_dailyPnlBaselines.symbols).length > 0;
                            if (!hasBaseline) _backfillDailyPnlSystemData('manual_pull_no_baseline');
                        }
                    } catch(_) {}
                }, 8000);

                const t = new Date().toLocaleTimeString('zh-TW');
                const _depPull = deposits.length > 0 ? ` + ${deposits.length} 筆存款` : '';
                setGistStatus(`✅ 已拉取 ${holdings.length} 筆持倉${_depPull}（${t}）`, '#10b981');
                showImportToast(`✅ 已從雲端拉取 ${holdings.length} 筆持倉${_depPull}`, 2500);

            } catch(e) {
                setGistStatus(`❌ 拉取失敗：${e.message}`, '#ef4444');
                // v15.064：記錄到錯誤日誌
                _recordAppError('gist_pull', e);
            } finally {
                _isApplyingCloudPull = false;   // v15.075：解除防反彈 flag
            }
        }

        // ── 啟動時靜默自動拉取 Gist ──
        // #region Gist Silent Pull
        async function _gistSilentPull() {
            const token  = localStorage.getItem(GIST_TOKEN_KEY);
            const gistId = localStorage.getItem(GIST_ID_KEY);
            if (!token || !gistId) return; // 無憑證，跳過

            try {
                const gistState = await _fetchGistState(token, gistId);
                const saved = gistState.saved;
                if (!saved) return;

                if (!Array.isArray(saved.holdings) || saved.holdings.length === 0) return;

                // Schema 版本檢查：雲端比本機新時靜默拒絕，並以 toast 提醒更新
                const _savedSchema = saved.schema_version || 1;
                if (_savedSchema > PT_SCHEMA_VERSION) {
                    console.warn(`[AutoPull] Gist schema v${_savedSchema} > 本機 v${PT_SCHEMA_VERSION}，跳過拉取`);
                    showWarnToast(`雲端資料是較新版本（v${_savedSchema}）產生，請更新 PWA 後再同步`);
                    return;
                }

                // v15.079：hash-first + master flag detection
                const v2 = await _classifyCloudSyncStateV2(gistState);
                const _localHashV = v2.localHash;
                const _cloudHashV = v2.cloudHash;
                const _masterFlag = saved.sync_meta?.userConfirmedCloudMaster || null;
                const _hasUnprocessedMaster = !!(_masterFlag && _masterFlag.id && !_isMasterIdProcessed(_masterFlag.id));

                // hash 相同 → user data 不覆蓋，但 v15.080 仍 merge system data（snapshots / baselines / price_cache）
                if (v2.kind === 'hash_match') {
                    // merge daily_pnl_snapshots
                    try {
                        if (saved.daily_pnl_snapshots && saved.daily_pnl_snapshots.markets) {
                            const merged = _mergeDailyPnlSnapshots(_loadDailyPnlSnapshots(), saved.daily_pnl_snapshots, _localHashV);
                            _saveDailyPnlSnapshots(merged);
                        }
                    } catch(_) {}
                    // 套用 baselines / price_cache 並 hydrate _prevCloseCache
                    try { _applySystemDataFromPayload(saved); } catch(_) {}
                    _applySyncBaseline(gistState, { userDataHash: _localHashV });
                    if (_hasUnprocessedMaster) _addProcessedMasterId(_masterFlag.id);
                    try { renderAll(); } catch(_) {}
                    console.log('[AutoPull] hash_match — user data 不覆蓋，但 system data 已 merge');
                    return;
                }

                // master flag 未處理 → 強制 auto-pull（使用者已宣告雲端主版本）
                // v15.079 hotfix：先記下要處理的 id，等套用成功後才標記 processed，
                // 避免 apply 中途 throw（catch 只 console.warn）導致 master id 已消化但本機沒套用
                let _forceApplyCloud = false;
                let _pendingMasterId = null;
                if (_hasUnprocessedMaster) {
                    console.log('[AutoPull] master flag detected, forcing apply cloud:', _masterFlag.id);
                    _pendingMasterId = _masterFlag.id;
                    _forceApplyCloud = true;
                }

                // 既有 6-state classify（hash 不同且無 master flag）
                const cls = v2.kind;
                if (!_forceApplyCloud) {
                    if (cls === 'clean_cloud_same') {
                        return;   // 雲端 = 本機 baseline，無事
                    }
                    if (cls === 'dirty_cloud_same') {
                        // 本機有未上傳修改但 baseline 對齊雲端 → 安全 push
                        setGistStatus('本機有未上傳修改，啟動推送…', '#fbbf24');
                        _gistSilentPush();
                        return;
                    }
                    if (cls === 'dirty_cloud_newer_conflict') {
                        showWarnToast(`❌ 雲端已有新版（${_fmtSyncTs(gistState.cloudUpdatedAt)}），本機也有未上傳修改。請手動「拉取」覆蓋本機，或在「推送」時選強制覆蓋。`, 5000);
                        setGistStatus('❌ 同步衝突：請手動處理雲端與本機差異', '#ef4444');
                        return;
                    }
                    if (cls === 'no_cloud_base' || cls === 'dirty_no_cloud') {
                        setGistStatus('⚠ 同步基準未建立，請手動推送或拉取一次', '#fbbf24');
                        return;
                    }
                }
                // clean_cloud_newer / clean_no_cloud / _forceApplyCloud → 套用雲端資料（auto pull）
                _isApplyingCloudPull = true;
                holdings = saved.holdings;
                holdings.forEach(h => h.persist = true);
                if (saved.currency)      currency = saved.currency;
                if (saved.exchangeRates) {
                    exchangeRates = saved.exchangeRates;
                    syncRateInputs();
                }
                if (saved.sheet_url) {
                    const sheetEl = document.getElementById('sheet-url');
                    if (sheetEl) sheetEl.value = saved.sheet_url;
                    saveSheetUrlSetting();
                }
                // ── 時間戳比較：若本地有未推送的修改（比 Gist 更新），跳過存款/已實現損益覆蓋 ──
                const _localModTs = localStorage.getItem(PT_LOCAL_MODIFY_TS) || '';
                const _gistPushedAt = saved.pushedAt || '';
                const _gistIsNewer = !_localModTs || _gistPushedAt >= _localModTs;

                // 還原存款資料
                if (Array.isArray(saved.deposits) && saved.deposits.length > 0) {
                    if (_gistIsNewer || deposits.length === 0) {
                        deposits = saved.deposits;
                        saveDeposits();
                    } else {
                        console.log('[Auto-pull] 本地存款較新，跳過 Gist 覆蓋');
                    }
                }
                if (saved.cash_pie_cb != null) {
                    localStorage.setItem(PT_CASH_PIE_KEY, saved.cash_pie_cb ? '1' : '0');
                    const cb = document.getElementById('cash-pie-cb');
                    if (cb) cb.checked = !!saved.cash_pie_cb;
                }
                if (saved.crypto_twd != null) {
                    const v = saved.crypto_twd || 0;
                    if (v > 0) localStorage.setItem(PT_CRYPTO_KEY, v); else localStorage.removeItem(PT_CRYPTO_KEY);
                    const el = document.getElementById('crypto-twd-input');
                    if (el) el.value = v > 0 ? v : '';
                }
                if (saved.crypto_pie_cb != null) {
                    localStorage.setItem(PT_CRYPTO_PIE_KEY, saved.crypto_pie_cb ? '1' : '0');
                    const cb = document.getElementById('crypto-pie-cb');
                    if (cb) cb.checked = !!saved.crypto_pie_cb;
                }
                if (saved.moxa_twd != null) {
                    const v = saved.moxa_twd || 0;
                    if (v > 0) localStorage.setItem(PT_MOXA_KEY, v); else localStorage.removeItem(PT_MOXA_KEY);
                    const el = document.getElementById('moxa-twd-input');
                    if (el) el.value = v > 0 ? v : '';
                }
                if (saved.moxa_pie_cb != null) {
                    localStorage.setItem(PT_MOXA_PIE_KEY, saved.moxa_pie_cb ? '1' : '0');
                    const cb = document.getElementById('moxa-pie-cb');
                    if (cb) cb.checked = !!saved.moxa_pie_cb;
                }
                if (Array.isArray(saved.watchlist)) {
                    watchlist = saved.watchlist;
                    saveWatchlist();
                    renderWatchlist();
                }
                // 還原已實現損益紀錄
                if (Array.isArray(saved.tradeHistory) && saved.tradeHistory.length > 0) {
                    if (_gistIsNewer || tradeHistory.length === 0) {
                        tradeHistory = saved.tradeHistory;
                        saveTradeHistory();
                    } else {
                        console.log('[Auto-pull] 本地已實現損益較新，跳過 Gist 覆蓋');
                    }
                }
                // 還原市值快照
                if (Array.isArray(saved.marketSnapshots)) { marketSnapshots = saved.marketSnapshots; saveSnapshots(); }
                // v15.071/080：merge 雲端 daily_pnl_snapshots 進本機（傳本機 hash 給 priority 用）
                try {
                    if (saved.daily_pnl_snapshots && saved.daily_pnl_snapshots.markets) {
                        const merged = _mergeDailyPnlSnapshots(_loadDailyPnlSnapshots(), saved.daily_pnl_snapshots, _cloudHashV || _localHashV);
                        _saveDailyPnlSnapshots(merged);
                    }
                } catch(_) {}
                // v15.080：force-apply 路徑也套用 system data（baselines / price_cache）+ hydrate
                try { _applySystemDataFromPayload(saved); } catch(_) {}

                _storageReady = true;
                // v15.075/079：統一寫 baseline + 清 dirty + 清 pending；pull 完成後本機 hash = 雲端 hash
                _applySyncBaseline(gistState, { userDataHash: _cloudHashV || _localHashV });
                // v15.079 hotfix：套用成功後才標記 master id processed
                if (_pendingMasterId) _addProcessedMasterId(_pendingMasterId);
                saveToStorage();
                // v15.069：Gist pull 後立刻 hydrate 既有 cache 並排程一次 loadAnalysis，
                //   讓新裝置不用等 1hr 就能看到今日/昨日損益
                try { _hydrateDailyPnlCachesFromAnalysisCache(); } catch(_) {}
                renderAll();
                try {
                    if (typeof loadAnalysis === 'function' && holdings.length > 0) {
                        setTimeout(() => loadAnalysis(false, true), 1500);
                    }
                } catch(_) {}
                const _depNote = deposits.length > 0 ? ` + ${deposits.length} 筆存款` : '';
                showImportToast(`☁️ 已從雲端載入 ${holdings.length} 筆庫存${_depNote}`, 3000);

            } catch(e) {
                console.warn('[Auto-pull] 靜默拉取失敗：', e.message);
            } finally {
                _isApplyingCloudPull = false;   // v15.075：解除防反彈 flag
            }
        }

        // ── 雲端 CSV 路徑設定（獨立於持倉 localStorage）──
        const SHEET_URL_KEY = 'pt_sheet_url_v15';

        function saveSheetUrlSetting() {
            const url = document.getElementById('sheet-url')?.value?.trim() || '';
            const remember = document.getElementById('sheet-url-remember')?.checked;
            const label = document.getElementById('sheet-url-remember-label');
            const status = document.getElementById('sheet-url-status');

            if (remember) {
                // 打勾 → 存到 localStorage
                localStorage.setItem(SHEET_URL_KEY, url);
                if (label) { label.textContent = '✓ 已記住路徑'; label.style.color = '#10b981'; }
                if (status && url) status.textContent = '✓ 路徑已儲存，下次開啟自動帶入';
            } else {
                // 沒打勾 → 清除 localStorage
                localStorage.removeItem(SHEET_URL_KEY);
                if (label) { label.textContent = '下次開啟記住此路徑'; label.style.color = '#64748b'; }
                if (status) status.textContent = url ? '⚠ 路徑未儲存，關閉後消失' : '';
            }
            if (status && !url) status.textContent = '';
        }

        const _DEFAULT_SHEET_URL = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vQnBPPnq7jgMZ3oZ8UVaxe77InNipxW-ItNAoqxQrAgnKfLNqX1P4xxOLMqKGjKWTRIN-VZ4SkgKFBt/pub?gid=0&single=true&output=csv';
        function fillDefaultSheetUrl() {
            const el = document.getElementById('sheet-url');
            if (el) { el.value = _DEFAULT_SHEET_URL; saveSheetUrlSetting(); }
        }

        function clearSheetUrl() {
            const el = document.getElementById('sheet-url');
            if (el) el.value = '';
            localStorage.removeItem(SHEET_URL_KEY);
            const label = document.getElementById('sheet-url-remember-label');
            const cb = document.getElementById('sheet-url-remember');
            const status = document.getElementById('sheet-url-status');
            if (label) { label.textContent = '下次開啟記住此路徑'; label.style.color = '#64748b'; }
            if (cb) cb.checked = false;
            if (status) status.textContent = '';
            saveToStorage();
        }

        function loadSheetUrlSetting() {
            const saved = localStorage.getItem(SHEET_URL_KEY);
            const el = document.getElementById('sheet-url');
            const cb = document.getElementById('sheet-url-remember');
            const label = document.getElementById('sheet-url-remember-label');
            const status = document.getElementById('sheet-url-status');
            if (saved && el) {
                el.value = saved;
                if (cb) cb.checked = true;
                if (label) { label.textContent = '✓ 已記住路徑'; label.style.color = '#10b981'; }
                if (status) status.textContent = '✓ 已自動帶入上次儲存的路徑';
            }
        }

        function saveToStorage() {
            if (!_storageReady) return;
            try {
                const persistedHoldings = holdings.filter(h => h.persist === true);
                const state = {
                    holdings: persistedHoldings,
                    sheetUrl: document.getElementById('sheet-url')?.value || '',
                    currency,
                    exchangeRates,
                    savedAt: new Date().toISOString()
                };
                if (persistedHoldings.length > 0) {
                    localStorage.setItem(PT_STORAGE_KEY, JSON.stringify(state));
                } else {
                    localStorage.removeItem(PT_STORAGE_KEY);
                }
            } catch(e) { /* 超出容量時靜默失敗 */ }
        }

        function loadFromStorage() {
            // ① 先還原持倉（最重要，獨立 try/catch，失敗直接回傳 false）
            let state = null;
            try {
                const raw = localStorage.getItem(PT_STORAGE_KEY);
                if (!raw) return false;
                state = JSON.parse(raw);
                if (Array.isArray(state.holdings) && state.holdings.length > 0) {
                    holdings = state.holdings;
                }
            } catch(e) { return false; }

            // ② 還原其他設定（失敗不影響持倉顯示）
            try {
                if (state.sheetUrl) {
                    const el = document.getElementById('sheet-url');
                    if (el) el.value = state.sheetUrl;
                }
                if (state.currency) currency = state.currency;
                if (state.exchangeRates?.USD_TWD) {
                    exchangeRates.USD_TWD = state.exchangeRates.USD_TWD;
                    exchangeRates.HKD_TWD = state.exchangeRates.HKD_TWD || exchangeRates.HKD_TWD;
                    syncRateInputs();
                }
            } catch(e) { /* 設定還原失敗不影響持倉 */ }

            return holdings.length > 0;
        }

        // ==================== 操作 ====================
        function getSymbolMarket(symbol) {
            const s = symbol.toUpperCase().trim();
            if (s.endsWith('.HK')) return 'HK';
            if (s.endsWith('.TW') || /^\d{4}$/.test(s)) return 'TW';
            return 'US';
        }
        function getSymbolCurrency(symbol) {
            const s = symbol.toUpperCase().trim();
            if (s.endsWith('.HK')) return HK_USD_PRICED.has(s) ? 'USD' : 'HKD';
            if (s.endsWith('.TW') || /^\d{4}$/.test(s)) return 'TWD';
            return 'USD';
        }
        function onSymbolInput(val) {
            const s = val.toUpperCase().trim();
            if (!s) return;
            document.getElementById('form-market').value = getSymbolMarket(s);
            document.getElementById('form-price-ccy').textContent = '(' + getSymbolCurrency(s) + ')';
        }
        // 市場手動切換時，重新計算幣別顯示
        function onMarketChange(market) {
            const sym = document.getElementById('form-symbol').value.trim().toUpperCase();
            if (!sym) return;
            document.getElementById('form-price-ccy').textContent = '(' + (
                market === 'HK' ? (HK_USD_PRICED.has(sym.endsWith('.HK') ? sym : sym + '.HK') ? 'USD' : 'HKD') :
                market === 'TW' ? 'TWD' : 'USD'
            ) + ')';
        }

        function addHolding() {
            let symbol = document.getElementById('form-symbol').value.trim().toUpperCase();
            const quantity  = parseFloat(document.getElementById('form-quantity').value);
            const costPrice = parseFloat(document.getElementById('form-cost').value);
            const market    = document.getElementById('form-market').value;
            // 自動補後綴：港股不帶 .HK 時補上
            if (market === 'HK' && !symbol.endsWith('.HK')) symbol = symbol + '.HK';
            const isBuy = tradeType === 'buy';
            if (!symbol || !quantity) return alert('請填寫所有必要欄位');
            if (!costPrice) return alert(isBuy ? '請填寫買入價格' : '請填寫賣出價格');
            saveHistory();
            const existingIndex = holdings.findIndex(h => h.symbol === symbol);

            if (isBuy) {
                // ── 買入：新增批次 (lot) ──
                const newLot = { qty: quantity, cost: costPrice, date: new Date().toISOString() };
                if (existingIndex !== -1) {
                    const existing = holdings[existingIndex];
                    _ensureLots(existing);
                    existing.lots.push(newLot);
                    // 從 lots 重算 quantity & 加權平均成本
                    existing.quantity  = existing.lots.reduce((s, l) => s + l.qty, 0);
                    existing.costPrice = parseFloat((existing.lots.reduce((s, l) => s + l.qty * l.cost, 0) / existing.quantity).toFixed(4));
                } else {
                    holdings.push({
                        id: Date.now(), symbol, market, name: '',
                        quantity, costPrice,
                        currentPrice: costPrice,
                        addedDate: new Date().toISOString(),
                        persist: false,
                        lots: [newLot]
                    });
                }
            } else {
                // ── 賣出：FIFO 消耗 lots，計算已實現損益 ──
                if (existingIndex === -1) return alert('找不到持倉，無法賣出');
                const existing = holdings[existingIndex];
                _ensureLots(existing);
                const totalHeld = existing.lots.reduce((s, l) => s + l.qty, 0);
                if (quantity > totalHeld + 0.000001) return alert('賣出數量超過持有股數');

                let remaining = quantity;
                let totalRealizedPL = 0;
                const lotsConsumed = [];
                for (let i = 0; i < existing.lots.length && remaining > 0.000001; i++) {
                    const lot    = existing.lots[i];
                    const consume = Math.min(lot.qty, remaining);
                    const realPL  = (costPrice - lot.cost) * consume;
                    totalRealizedPL += realPL;
                    lotsConsumed.push({ qty: consume, cost: lot.cost, date: lot.date });
                    lot.qty   -= consume;
                    remaining -= consume;
                }
                // 清除已耗盡的 lot
                existing.lots = existing.lots.filter(l => l.qty > 0.000001);

                if (existing.lots.length === 0) {
                    holdings.splice(existingIndex, 1);
                } else {
                    existing.quantity  = existing.lots.reduce((s, l) => s + l.qty, 0);
                    existing.costPrice = parseFloat((existing.lots.reduce((s, l) => s + l.qty * l.cost, 0) / existing.quantity).toFixed(4));
                }

                // 記錄到 tradeHistory
                tradeHistory.push({
                    id: Date.now(),
                    symbol, market,
                    type: 'sell',
                    qty: quantity,
                    price: costPrice,
                    date: new Date().toISOString(),
                    realizedPL: parseFloat(totalRealizedPL.toFixed(4)),
                    lotsConsumed
                });
                saveTradeHistory();
            }

            // 買入 / 賣出都觸發 auto-push（v15.056 修正：原本只有賣出觸發）
            _markAndAutoPush(isBuy ? ['holdings'] : ['holdings', 'tradeHistory']);
            alert(isBuy ? `✅ 已買入 ${symbol}` : `✅ 已賣出 ${symbol}，已實現損益 ${tradeHistory[tradeHistory.length-1]?.realizedPL >= 0 ? '+' : ''}${tradeHistory[tradeHistory.length-1]?.realizedPL?.toFixed(2) ?? ''}`);
            document.getElementById('form-symbol').value  = '';
            document.getElementById('form-quantity').value = '';
            document.getElementById('form-cost').value    = '';
            renderAll();
        }

        function updateQuantity(id, newQty) {
            const parsed = parseFloat(newQty); if (isNaN(parsed)) return;
            saveHistory();
            const h = holdings.find(item => item.id === id);
            if (h) { h.quantity = parsed; _resetLots(h); _markAndAutoPush(['holdings']); }
            renderAll();
        }
        function updateCostPrice(id, newCost) {
            const parsed = parseFloat(newCost); if (isNaN(parsed)) return;
            saveHistory();
            const h = holdings.find(item => item.id === id);
            if (h) { h.costPrice = parsed; _resetLots(h); _markAndAutoPush(['holdings']); }
            renderAll();
        }
        function updateCurrentPrice(id, newPrice) { const parsed = parseFloat(newPrice); if (isNaN(parsed)) return; saveHistory(); const h = holdings.find(item => item.id === id); if (h) { h.currentPrice = parsed; _markAndAutoPush(['holdings']); } renderAll(); }
        function deleteHolding(id) {
            currentDeleteId = id;
            const h = holdings.find(item => item.id === id);
            document.getElementById('confirm-text').innerHTML = `確定要刪除「${h.symbol}」的持倉嗎？<br>此操作無法復原。`;
            document.getElementById('confirm-modal').style.display = 'flex';
        }
        function confirmDelete() {
            saveHistory();
            const deletedId = currentDeleteId;
            holdings = holdings.filter(h => h.id !== deletedId);
            // 直接從 localStorage 移除該筆，確保 persist:true 的持倉也能被刪除
            try {
                const raw = localStorage.getItem(PT_STORAGE_KEY);
                if (raw) {
                    const state = JSON.parse(raw);
                    if (Array.isArray(state.holdings)) {
                        state.holdings = state.holdings.filter(h => h.id !== deletedId);
                        if (state.holdings.length > 0) {
                            localStorage.setItem(PT_STORAGE_KEY, JSON.stringify(state));
                        } else {
                            localStorage.removeItem(PT_STORAGE_KEY);
                        }
                    }
                }
            } catch(_) {}
            hideConfirmModal();
            _markAndAutoPush(['holdings']);
            renderAll();
        }

        // ── 持倉保留勾選 ──
        function togglePersist(id, checked) {
            const h = holdings.find(item => item.id === id);
            if (!h) return;
            h.persist = checked;
            saveToStorage();
            _markAndAutoPush(['holdings']);
            renderAll();
            showImportToast(checked ? '✅ 已設定保留，下次開啟仍在' : 'ℹ️ 已取消保留，關閉後消失', 2000);
        }

        function toggleAllPersist(checked) {
            holdings.forEach(h => h.persist = checked);
            saveToStorage();
            _markAndAutoPush(['holdings']);
            renderAll();
            showImportToast(checked ? '✅ 已設定全部保留' : 'ℹ️ 已取消全部保留', 2000);
        }

        function syncPersistAllCheckbox() {
            const cb = document.getElementById('persist-all-checkbox');
            const txt = document.getElementById('persist-all-text');
            if (!cb || holdings.length === 0) return;
            const allPersist  = holdings.every(h => h.persist);
            const nonePersist = holdings.every(h => !h.persist);
            cb.checked = allPersist;
            cb.indeterminate = !allPersist && !nonePersist;
            txt.innerHTML = '<i class="ic">◻</i> 下次開啟仍保留';
            txt.style.color = allPersist ? '#10b981' : nonePersist ? '#64748b' : '#3b82f6';
        }
        function hideConfirmModal() { document.getElementById('confirm-modal').style.display = 'none'; currentDeleteId = null; }

        let pendingCsvRows = [];
        let pendingCsvTrades = [];
        let pendingCsvDeposits = null;   // v15.077：CSV 匯入暫存的存款列表
        let pendingCsvOther    = null;   // v15.077：CSV 匯入暫存的單值欄位 map

        function showImportConfirm() {
            // 每次開啟時重置狀態
            pendingCsvRows = []; pendingCsvTrades = [];
            document.getElementById('csv-preview-wrap').style.display = 'none';
            document.getElementById('csv-preview-count').textContent = '';
            document.getElementById('csv-preview-error').textContent = '';
            document.getElementById('csv-file-input').value = '';
            const dz = document.getElementById('csv-drop-zone');
            dz.style.borderColor = 'rgba(59,130,246,0.4)';
            dz.style.background = 'rgba(15,30,60,0.4)';
            document.getElementById('import-modal').style.display = 'flex';
        }
        function hideImportModal() { document.getElementById('import-modal').style.display = 'none'; }

        function handleCsvDrop(event) {
            event.preventDefault();
            const dz = document.getElementById('csv-drop-zone');
            dz.style.borderColor = 'rgba(59,130,246,0.4)';
            dz.style.background = 'rgba(15,30,60,0.4)';
            const file = event.dataTransfer.files[0];
            if (file) handleCsvFile(file);
        }

        function handleCsvFile(file) {
            if (!file) return;
            if (!file.name.toLowerCase().endsWith('.csv') && file.type !== 'text/csv') {
                alert('請選擇 .csv 格式的檔案');
                return;
            }
            const reader = new FileReader();
            reader.onload = e => parseCsvPreview(e.target.result);
            reader.readAsText(file, 'UTF-8');
        }

        function parseCSVLine(line) {
            // 支援引號包覆欄位（RFC 4180），自動偵測 Tab 或逗號分隔
            const delimiter = line.includes('\t') ? '\t' : ',';
            const cols = [];
            let cur = '', inQuote = false;
            for (let i = 0; i < line.length; i++) {
                const ch = line[i];
                if (inQuote) {
                    if (ch === '"' && line[i+1] === '"') { cur += '"'; i++; }
                    else if (ch === '"') { inQuote = false; }
                    else { cur += ch; }
                } else {
                    if (ch === '"') { inQuote = true; }
                    else if (ch === delimiter) { cols.push(cur.trim()); cur = ''; }
                    else { cur += ch; }
                }
            }
            cols.push(cur.trim());
            return cols;
        }

        function parseCsvPreview(csvText) {
            // 移除 BOM
            csvText = csvText.replace(/^﻿/, '');

            // ── v15.077：依序分離 [TradeHistory] / [Deposits] / [OtherAssets] 區段 ──
            let holdingsPart = csvText;
            let tradeHistoryPart = '', depositsPart = '', otherAssetsPart = '';
            const _markers = [
                { key: 'tradeHistory', tag: '[TradeHistory]' },
                { key: 'deposits',     tag: '[Deposits]' },
                { key: 'otherAssets',  tag: '[OtherAssets]' }
            ];
            const _positions = _markers
                .map(m => ({ ...m, idx: csvText.indexOf(m.tag) }))
                .filter(p => p.idx >= 0)
                .sort((a, b) => a.idx - b.idx);
            if (_positions.length > 0) {
                holdingsPart = csvText.substring(0, _positions[0].idx);
                _positions.forEach((p, i) => {
                    const start = p.idx + p.tag.length;
                    const end   = (i + 1 < _positions.length) ? _positions[i + 1].idx : csvText.length;
                    const seg   = csvText.substring(start, end);
                    if (p.key === 'tradeHistory') tradeHistoryPart = seg;
                    else if (p.key === 'deposits') depositsPart = seg;
                    else if (p.key === 'otherAssets') otherAssetsPart = seg;
                });
            }

            // ── 解析持倉 ──
            const lines = holdingsPart.trim().split(/\r?\n|\r/).filter(l => l.trim());
            if (lines.length < 2) {
                showCsvError('CSV 內容為空或只有標題行');
                return;
            }

            const firstLine = lines[0].replace(/"/g, '').toLowerCase();
            const hasHeader = firstLine.includes('symbol') || firstLine.includes('market') || firstLine.includes('quantity');
            const dataLines = hasHeader ? lines.slice(1) : lines;

            const rows = [];
            const errors = [];
            dataLines.forEach((line, i) => {
                const cols = parseCSVLine(line);
                const symbol = cols[0];
                const market = (cols[1] || 'US').toUpperCase();
                const name = cols[2] || '';
                const quantity = parseFloat(cols[3]);
                const costPrice = parseFloat(cols[4]);
                const currentPrice = parseFloat(cols[5]) || costPrice;
                const addedDate = cols[6] || new Date().toISOString();

                if (!symbol) { errors.push(`第${i+2}行：代碼為空`); return; }
                if (isNaN(quantity) || quantity <= 0) { errors.push(`第${i+2}行 ${symbol}：股數無效`); return; }
                if (isNaN(costPrice) || costPrice <= 0) { errors.push(`第${i+2}行 ${symbol}：成本價無效`); return; }

                const h = { id: Date.now() + i, symbol, market, name, quantity, costPrice, currentPrice, addedDate, persist: false };
                // 還原 lots（第 8 欄，JSON）
                if (cols[7]) { try { const l = JSON.parse(cols[7]); if (Array.isArray(l) && l.length) h.lots = l; } catch(_) {} }
                rows.push(h);
            });

            // ── 解析已實現損益 ──
            const importedTrades = [];
            if (tradeHistoryPart.trim()) {
                const tLines = tradeHistoryPart.trim().split(/\r?\n|\r/).filter(l => l.trim());
                const tFirst = (tLines[0] || '').replace(/"/g, '').toLowerCase();
                const tHasHeader = tFirst.includes('symbol') || tFirst.includes('qty') || tFirst.includes('price');
                const tDataLines = tHasHeader ? tLines.slice(1) : tLines;
                tDataLines.forEach(line => {
                    const c = parseCSVLine(line);
                    if (!c[0]) return;
                    let lc = [];
                    if (c[6]) { try { lc = JSON.parse(c[6]); } catch(_) {} }
                    importedTrades.push({ symbol: c[0], market: c[1]||'US', qty: parseFloat(c[2])||0, price: parseFloat(c[3])||0, date: c[4]||'', realizedPL: parseFloat(c[5])||0, lotsConsumed: lc });
                });
            }

            // v15.077：解析 [Deposits]
            let importedDeposits = null;
            if (depositsPart.trim()) {
                const dLines = depositsPart.trim().split(/\r?\n|\r/).filter(l => l.trim());
                const dFirst = (dLines[0] || '').toLowerCase();
                const dHasHeader = dFirst.includes('bank') || dFirst.includes('currency') || dFirst.includes('amount');
                const dData = dHasHeader ? dLines.slice(1) : dLines;
                importedDeposits = [];
                dData.forEach(line => {
                    const c = parseCSVLine(line);
                    const bank = (c[0] || '').trim();
                    const cur  = (c[1] || 'TWD').toUpperCase();
                    const amt  = parseFloat(c[2]) || 0;
                    if (bank && amt > 0) importedDeposits.push({ id: Date.now() + Math.random(), bank, currency: cur, amount: amt });
                });
            }
            // v15.077：解析 [OtherAssets]（key=value 單值欄位）
            let importedOther = null;
            if (otherAssetsPart.trim()) {
                importedOther = {};
                otherAssetsPart.trim().split(/\r?\n|\r/).forEach(line => {
                    const eq = line.indexOf('=');
                    if (eq < 0) return;
                    const k = line.substring(0, eq).trim();
                    const v = line.substring(eq + 1).trim();
                    if (k) importedOther[k] = v;
                });
            }

            pendingCsvRows = rows;
            pendingCsvTrades = importedTrades;
            pendingCsvDeposits = importedDeposits;
            pendingCsvOther = importedOther;
            if (rows.length > 0) {
                // 自動匯入，不需要按確認鍵
                confirmCsvImport();
            } else {
                renderCsvPreview(rows, errors);
            }
        }

        function renderCsvPreview(rows, errors) {
            const wrap = document.getElementById('csv-preview-wrap');
            const countEl = document.getElementById('csv-preview-count');
            const errEl = document.getElementById('csv-preview-error');
            const tbody = document.getElementById('csv-preview-tbody');
            countEl.textContent = rows.length > 0 ? `✓ 解析到 ${rows.length} 筆持倉` : '';
            errEl.textContent = errors.length > 0 ? `⚠ ${errors.length} 行跳過：${errors.slice(0,2).join('；')}` : '';

            tbody.innerHTML = rows.map(r => `
                <tr style="border-bottom:1px solid rgba(255,255,255,0.05);">
                    <td style="padding:0.35rem 0.5rem; font-weight:600; color:#f1f5f9;">${r.symbol}</td>
                    <td style="padding:0.35rem 0.5rem; text-align:center; color:#a8bdd0;">${r.market==='TW'?'🇹🇼':r.market==='HK'?'🇭🇰':'🇺🇸'}</td>
                    <td style="padding:0.35rem 0.5rem; color:#a8bdd0; max-width:180px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;">${r.name||'-'}</td>
                    <td style="padding:0.35rem 0.5rem; text-align:right; color:#e2e8f0;">${r.quantity.toLocaleString()}</td>
                    <td style="padding:0.35rem 0.5rem; text-align:right; color:#a8bdd0;">${r.costPrice}</td>
                    <td style="padding:0.35rem 0.5rem; text-align:right; color:#60a5fa;">${r.currentPrice}</td>
                </tr>`).join('');

            wrap.style.display = (rows.length > 0 || errors.length > 0) ? 'block' : 'none';
        }

        function showCsvError(msg) {
            document.getElementById('csv-preview-count').textContent = '';
            document.getElementById('csv-preview-error').textContent = '❌ ' + msg;
            document.getElementById('csv-preview-wrap').style.display = 'block';
            document.getElementById('csv-preview-tbody').innerHTML = '';
        }

        function confirmCsvImport() {
            if (pendingCsvRows.length === 0) return;
            saveHistory();
            const n = pendingCsvRows.length;
            holdings = pendingCsvRows;
            pendingCsvRows = [];
            // 還原已實現損益
            const tn = pendingCsvTrades.length;
            if (tn > 0) { tradeHistory = pendingCsvTrades; saveTradeHistory(); }
            pendingCsvTrades = [];
            // v15.077：還原存款（向下相容：CSV 沒 [Deposits] 區段就保留本機）
            const dn = (pendingCsvDeposits && pendingCsvDeposits.length) || 0;
            if (pendingCsvDeposits && pendingCsvDeposits.length > 0) {
                deposits = pendingCsvDeposits;
                saveDeposits();
            }
            pendingCsvDeposits = null;
            // v15.077：還原 OtherAssets（crypto / moxa / pie_cb / sheet_url / currency；缺值保留本機）
            if (pendingCsvOther) {
                const o = pendingCsvOther;
                const _setBool = (k, cbId, lsKey) => {
                    if (o[k] == null) return;
                    const b = (o[k] === 'true' || o[k] === '1');
                    localStorage.setItem(lsKey, b ? '1' : '0');
                    const cb = document.getElementById(cbId); if (cb) cb.checked = b;
                };
                const _setNum = (k, inputId, lsKey) => {
                    if (o[k] == null) return;
                    const v = parseFloat(o[k]) || 0;
                    if (v > 0) localStorage.setItem(lsKey, v); else localStorage.removeItem(lsKey);
                    const el = document.getElementById(inputId); if (el) el.value = v > 0 ? v : '';
                };
                _setBool('cash_pie_cb',   'cash-pie-cb',   PT_CASH_PIE_KEY);
                _setNum ('crypto_twd',    'crypto-twd-input', PT_CRYPTO_KEY);
                _setBool('crypto_pie_cb', 'crypto-pie-cb', PT_CRYPTO_PIE_KEY);
                _setNum ('moxa_twd',      'moxa-twd-input',   PT_MOXA_KEY);
                _setBool('moxa_pie_cb',   'moxa-pie-cb',      PT_MOXA_PIE_KEY);
                if (o.sheet_url != null) {
                    const sEl = document.getElementById('sheet-url');
                    if (sEl) { sEl.value = o.sheet_url; saveSheetUrlSetting(); }
                }
                if (o.currency && (o.currency === 'USD' || o.currency === 'TWD')) {
                    currency = o.currency;
                    setCurrency(currency);
                }
            }
            pendingCsvOther = null;
            hideImportModal();
            _markAndAutoPush(tn > 0 ? ['holdings', 'tradeHistory'] : ['holdings']);
            renderAll();
            const msg = tn > 0 ? `✅ 已匯入 ${n} 筆持倉 + ${tn} 筆已實現損益，正在自動更新…` : `✅ 已匯入 ${n} 筆持倉，正在自動更新報價與分析數據…`;
            showImportToast(msg);
            // 自動串接：報價 → 分析數據
            autoRefreshAfterImport();
        }

        function showImportToast(msg, duration) {
            const toast = document.createElement('div');
            toast.textContent = msg;
            Object.assign(toast.style, {
                position:'fixed', bottom:'1.5rem', left:'50%', transform:'translateX(-50%)',
                background:'rgba(16,185,129,0.93)', color:'#060d1a',
                padding:'0.65rem 1.5rem', borderRadius:'20px', fontWeight:'700',
                fontSize:'0.92rem', zIndex:'9999',
                boxShadow:'0 4px 18px rgba(0,0,0,0.45)', pointerEvents:'none',
                whiteSpace:'nowrap'
            });
            document.body.appendChild(toast);
            setTimeout(() => toast.remove(), duration || 3000);
        }
        function showWarnToast(msg, duration) {
            const toast = document.createElement('div');
            toast.textContent = msg;
            Object.assign(toast.style, {
                position:'fixed', bottom:'1.5rem', left:'50%', transform:'translateX(-50%)',
                background:'rgba(239,68,68,0.93)', color:'#fff',
                padding:'0.65rem 1.5rem', borderRadius:'20px', fontWeight:'700',
                fontSize:'0.9rem', zIndex:'9999',
                boxShadow:'0 4px 18px rgba(0,0,0,0.45)', pointerEvents:'none',
                whiteSpace:'pre-line', textAlign:'center', maxWidth:'90vw'
            });
            document.body.appendChild(toast);
            setTimeout(() => toast.remove(), duration || 4000);
        }

        // v15.079：手動推送三選一 modal — 回 Promise<'master'|'staging'|'cancel'>
        function _promptPushMode() {
            return new Promise(resolve => {
                const modal = document.getElementById('push-mode-modal');
                if (!modal) return resolve('cancel');
                modal.style.display = 'flex';
                const close = (val) => {
                    modal.style.display = 'none';
                    document.getElementById('pm-master').onclick  = null;
                    document.getElementById('pm-staging').onclick = null;
                    document.getElementById('pm-cancel').onclick  = null;
                    resolve(val);
                };
                document.getElementById('pm-master').onclick  = () => close('master');
                document.getElementById('pm-staging').onclick = () => close('staging');
                document.getElementById('pm-cancel').onclick  = () => close('cancel');
            });
        }

        async function autoRefreshAfterImport() {
            // ① 更新報價（有設定 Google Sheet 時才執行）
            const sheetUrl = (document.getElementById('sheet-url')?.value || '').trim();
            if (sheetUrl && sheetUrl.includes('docs.google.com')) {
                await refreshAllData();
            }
            // ② 更新分析數據（基本面 + 技術面），強制重新抓取
            await loadAnalysis(true);
            showImportToast('✅ 報價與分析數據已全部更新完成', 2500);
        }

        function exportHoldings() {
            if (holdings.length === 0 && tradeHistory.length === 0 && deposits.length === 0) return alert('尚無持倉、交易或存款紀錄');
            // ── Holdings ──
            const hRows = [['Symbol','Market','Name','Quantity','Cost Price','Current Price','Added Date','Lots']];
            holdings.forEach(h => {
                hRows.push([h.symbol, h.market, h.name||'', h.quantity, h.costPrice, h.currentPrice, h.addedDate||'', JSON.stringify(h.lots||[])]);
            });
            let csv = hRows.map(r => r.join('\t')).join('\n');
            // ── TradeHistory（已實現損益）──
            if (tradeHistory.length > 0) {
                csv += '\n\n[TradeHistory]\n';
                const tRows = [['Symbol','Market','Qty','Price','Date','RealizedPL','LotsConsumed']];
                tradeHistory.forEach(t => {
                    tRows.push([t.symbol, t.market||'US', t.qty, t.price, t.date, t.realizedPL, JSON.stringify(t.lotsConsumed||[])]);
                });
                csv += tRows.map(r => r.join('\t')).join('\n');
            }
            // ── Deposits（v15.077：各銀行存款）──
            if (deposits.length > 0) {
                csv += '\n\n[Deposits]\n';
                const dRows = [['Bank','Currency','Amount']];
                deposits.forEach(d => {
                    dRows.push([d.bank || '', d.currency || 'TWD', d.amount || 0]);
                });
                csv += dRows.map(r => r.join('\t')).join('\n');
            }
            // ── OtherAssets（v15.077：crypto / moxa / pie 勾選 / sheet_url / currency 單值欄位）──
            const _other = [
                ['cash_pie_cb',   document.getElementById('cash-pie-cb')?.checked   ? 'true' : 'false'],
                ['crypto_twd',    parseFloat(document.getElementById('crypto-twd-input')?.value) || 0],
                ['crypto_pie_cb', document.getElementById('crypto-pie-cb')?.checked ? 'true' : 'false'],
                ['moxa_twd',      parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0],
                ['moxa_pie_cb',   document.getElementById('moxa-pie-cb')?.checked   ? 'true' : 'false'],
                ['sheet_url',     document.getElementById('sheet-url')?.value?.trim() || ''],
                ['currency',      currency || 'TWD']
            ];
            csv += '\n\n[OtherAssets]\n';
            csv += _other.map(([k, v]) => `${k}=${v}`).join('\n');

            const blob = new Blob(['\uFEFF' + csv], { type: 'text/csv;charset=utf-8;' });
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url; a.download = `portfolio_${new Date().toISOString().slice(0,10)}.csv`;
            a.click();
            URL.revokeObjectURL(url);
        }

        // ── Sheet CSV fetch（多 proxy fallback，解決 CORS）──
        const _SHEET_PROXIES = [
            u => 'https://api.allorigins.win/raw?url='          + encodeURIComponent(u),
            u => 'https://api.codetabs.com/v1/proxy?quest='     + encodeURIComponent(u),
            u => 'https://corsproxy.io/?'                       + encodeURIComponent(u),
        ];
        async function _fetchSheetCSV(sheetUrl, signal) {
            const lastErrors = [];
            for (const mkProxy of _SHEET_PROXIES) {
                const ctrl = new AbortController();
                const tid  = setTimeout(() => ctrl.abort(), 7000);
                // 若外部 signal 已 abort，立即停止
                signal?.addEventListener('abort', () => ctrl.abort());
                try {
                    const res = await fetch(mkProxy(sheetUrl), { signal: ctrl.signal, cache: 'no-store' });
                    clearTimeout(tid);
                    if (res.ok) return res;
                    lastErrors.push(`HTTP ${res.status}`);
                } catch(e) {
                    clearTimeout(tid);
                    lastErrors.push(e?.message || 'fetch error');
                }
            }
            // v15.064：三 proxy 全滅時記錄錯誤日誌（包含每個 proxy 的失敗原因）
            try {
                _recordAppError('csv_proxy_all_fail', new Error('All CSV proxies failed'), { errors: lastErrors });
            } catch(_) {}
            return null; // 全部失敗
        }

        async function refreshAllData() {
            const btn = document.getElementById('refresh-btn');
            const text = document.getElementById('refresh-text');
            const icon = document.getElementById('refresh-icon');
            btn.disabled = true; text.textContent = '更新中...'; icon.style.animation = 'spin 1s linear infinite';
            try {
                const sheetUrl = document.getElementById('sheet-url').value.trim();
                if (!sheetUrl) { showWarnToast('⚠️ 請先填入 Google Sheet CSV 連結'); return; }
                if (!sheetUrl.includes('docs.google.com')) { showWarnToast('⚠️ URL 格式不符，請使用 Google Sheets 已發布的 CSV 連結'); return; }

                // 同時發出：① 股價 CSV ② 即時匯率（手動更新 → 強制重新抓取，清快取）
                const fxPromise = _fetchFxRates(true);

                const controller = new AbortController();
                const timeoutId = setTimeout(() => controller.abort(), 25000);
                const res = await _fetchSheetCSV(sheetUrl, controller.signal);
                clearTimeout(timeoutId);
                if (!res) {
                    showWarnToast('⏱ 無法取得報價 CSV，三個 proxy 均失敗\n請確認 Google Sheet 已發布為 CSV 格式');
                    return;
                }
                const csvText = await res.text();

                if (csvText.trim().startsWith('<')) {
                    showWarnToast('❌ Google Sheet 尚未以 CSV 格式發布\n請至 檔案→共用→發布到網路→選逗號分隔值(.csv)');
                    return;
                }

                const prices = {};
                const sheetRates = {};
                csvText.trim().split(/\r?\n/).forEach(line => {
                    const cols = line.trim().split(',').map(c => c.replace(/"/g,'').trim());
                    const val = parseFloat(cols[1]);
                    if (cols.length < 2 || !cols[0] || isNaN(val) || val <= 0) return;
                    // 特殊 key：匯率覆蓋
                    if (cols[0] === 'USD_TWD') sheetRates.USD_TWD = val;
                    else if (cols[0] === 'HKD_TWD') sheetRates.HKD_TWD = val;
                    else prices[cols[0]] = val;
                });

                // 套用匯率：Sheet 指定 > 即時 API > 維持現值
                const fx = await fxPromise;
                let rateUpdated = false;
                if (sheetRates.USD_TWD) { exchangeRates.USD_TWD = sheetRates.USD_TWD; rateUpdated = true; }
                if (sheetRates.HKD_TWD) { exchangeRates.HKD_TWD = sheetRates.HKD_TWD; rateUpdated = true; }
                if (!rateUpdated && fx) {
                    exchangeRates.USD_TWD = fx.USD_TWD;
                    exchangeRates.HKD_TWD = fx.HKD_TWD;
                    rateUpdated = true;
                }
                if (rateUpdated) {
                    syncRateInputs();
                    const updated = new Date().toLocaleTimeString('zh-TW');
                    document.getElementById('rate-source').textContent = `✓ ${sheetRates.USD_TWD ? 'Sheet 覆蓋' : '即時匯率'}（${updated}）`;
                }

                if (Object.keys(prices).length === 0) {
                    showWarnToast('⚠️ CSV 無有效股價，請確認格式\n第一欄=代碼，第二欄=價格');
                    manualPriceReview();
                    return;
                }

                const matchCount = holdings.filter(h => _lookupPrice(prices, h) != null).length;
                if (matchCount === 0) {
                    const sheetSymbols = Object.keys(prices).slice(0, 3).join(', ');
                    const holdingSymbols = holdings.slice(0, 3).map(h => h.symbol).join(', ');
                    showWarnToast(`⚠️ 代碼不符\nSheet：${sheetSymbols}\n持倉：${holdingSymbols}`, 5000);
                    return;
                }

                directApplyPrices(prices);

            } catch(e) {
                alert(`❌ 更新失敗：${e.message}`);
            } finally {
                btn.disabled = false; text.textContent = '一鍵更新報價 + 匯率'; icon.style.animation = 'none';
            }
        }

        // 從 prices map 查找持倉對應報價（支援 .TW 後綴有無的彈性匹配）
        function _lookupPrice(prices, h) {
            if (prices[h.symbol] != null) return prices[h.symbol];
            // 台股：持倉存 "00675L" 但 Sheet 寫 "00675L.TW"（或反之）
            if (h.market === 'TW') {
                const withTW    = h.symbol + '.TW';
                const withoutTW = h.symbol.replace(/\.TW$/i, '');
                if (prices[withTW]    != null) return prices[withTW];
                if (prices[withoutTW] != null) return prices[withoutTW];
            }
            return null;
        }

        // 直接套用股價（不跳確認視窗）
        function directApplyPrices(prices) {
            saveHistory();
            let updated = 0;
            const updatedMarkets = new Set();   // v15.072：只標實際被刷到的市場
            holdings.forEach(h => {
                const newP = _lookupPrice(prices, h);
                if (newP != null && !isNaN(newP) && newP > 0) {
                    h.currentPrice = parseFloat(parseFloat(newP).toFixed(4));
                    updated++;
                    const mk = _holdingMarketKey(h);
                    if (mk === 'TW' || mk === 'HK' || mk === 'US') updatedMarkets.add(mk);
                }
            });
            // v15.072：手動 CSV apply 也只 mark 實際刷到的市場
            if (updatedMarkets.size > 0) {
                try { _markBatchQuoteRefresh([...updatedMarkets], 'csv-manual'); } catch(_) {}
            }
            // v15.080 後續修補：報價更新後若 _prevCloseCache 缺失，背景排 loadAnalysis 補正
            // （避免 currentPrice 已新但 prevClose 為空，今日漲幅顯示「-」過久）
            try {
                const _missingBaseline = holdings.some(h => {
                    const pc = window._prevCloseCache?.[h.symbol];
                    return pc == null || !(pc > 0);
                });
                if (_missingBaseline && typeof loadAnalysis === 'function') {
                    clearTimeout(window._missingBaselineTimer);
                    window._missingBaselineTimer = setTimeout(() => loadAnalysis(false, true), 1500);
                }
            } catch(_) {}
            renderAll();
            showImportToast(`✅ 已更新 ${updated} 檔股價`, 2000);
        }

        function manualPriceReview() {
            const reviewData = {};
            holdings.forEach(h => reviewData[h.symbol] = { oldPrice: h.currentPrice, newPrice: h.currentPrice, diff: 0, name: h.name||'' });
            priceReviewData = { prices: reviewData, accepted: Object.keys(reviewData).reduce((a,k)=>{a[k]=true;return a;}, {}) };
            showReviewModal();
        }
        function showPriceReview(allPrices) {
            const reviewData = {}; const accepted = {};
            holdings.forEach(h => {
                const newP = allPrices[h.symbol];
                if (newP != null && !isNaN(newP)) {
                    const newPrice = parseFloat(newP.toFixed(4));
                    const diff = Math.abs(newPrice - h.currentPrice) / h.currentPrice * 100;
                    reviewData[h.symbol] = { oldPrice: h.currentPrice, newPrice, diff: diff.toFixed(1), name: h.name||'' };
                    accepted[h.symbol] = diff < 15;
                }
            });
            priceReviewData = { prices: reviewData, accepted };
            showReviewModal();
        }
        function showReviewModal() {
            const modal = document.getElementById('review-modal');
            const tbody = document.getElementById('review-table');
            tbody.innerHTML = `
                <thead><tr style="border-bottom:2px solid rgba(56,139,253,0.3);"><th style="padding:0.5rem;text-align:center;color:#60a5fa;">✓</th><th style="padding:0.5rem;color:#60a5fa;">代碼</th><th style="padding:0.5rem;text-align:right;color:#60a5fa;">目前價</th><th style="padding:0.5rem;text-align:right;color:#60a5fa;">新價格</th><th style="padding:0.5rem;text-align:right;color:#60a5fa;">差異</th></tr></thead>
                <tbody>${Object.entries(priceReviewData.prices).map(([symbol, info]) => {
                    const checked = priceReviewData.accepted[symbol] ? 'background:#10b981;color:#fff' : '';
                    return `<tr>
                        <td onclick="toggleReviewAccept('${symbol}')" style="padding:0.5rem;text-align:center;cursor:pointer;"><div style="width:20px;height:20px;border-radius:4px;border:2px solid #10b981;${checked ? 'background:#10b981' : ''};margin:auto;">${priceReviewData.accepted[symbol]?'✓':''}</div></td>
                        <td style="padding:0.5rem;font-weight:600;cursor:pointer;" onclick="toggleReviewAccept('${symbol}')">${symbol}</td>
                        <td style="padding:0.5rem;text-align:right;color:#a8bdd0;">${info.oldPrice}</td>
                        <td style="padding:0.5rem;text-align:right;"><input type="number" value="${info.newPrice}" onchange="updateReviewPrice('${symbol}', this.value)" style="width:100px;text-align:right;background:rgba(59,130,246,0.1);border:1px solid rgba(59,130,246,0.3);border-radius:5px;color:#e2e8f0;"></td>
                        <td style="padding:0.5rem;text-align:right;color:#10b981;font-weight:600;">${info.diff}%</td>
                    </tr>`;
                }).join('')}</tbody>`;
            modal.style.display = 'flex';
        }
        function toggleReviewAccept(symbol) { priceReviewData.accepted[symbol] = !priceReviewData.accepted[symbol]; showReviewModal(); }
        function updateReviewPrice(symbol, val) {
            const newPrice = parseFloat(val);
            if (isNaN(newPrice)) return;
            priceReviewData.prices[symbol].newPrice = newPrice;
            const old = priceReviewData.prices[symbol].oldPrice;
            priceReviewData.prices[symbol].diff = (Math.abs(newPrice - old) / old * 100).toFixed(1);
            showReviewModal();
        }
        function applyManualRates() {
            const usd = parseFloat(document.getElementById('input-usd-twd').value);
            const hkd = parseFloat(document.getElementById('input-hkd-twd').value);
            if (!isNaN(usd) && usd > 0) exchangeRates.USD_TWD = usd;
            if (!isNaN(hkd) && hkd > 0) exchangeRates.HKD_TWD = hkd;
            document.getElementById('rate-source').textContent = '（手動設定）';
            renderAll();
        }

        function hideFxTable() {
            document.getElementById('fx-table-popup').style.display = 'none';
        }
        function _renderFxTable(extra, ts, fromCache) {
            const body   = document.getElementById('fx-table-body');
            const timeEl = document.getElementById('fx-table-time');
            const title  = document.getElementById('fx-table-title');
            if (!extra || Object.keys(extra).length === 0) {
                body.innerHTML = '<div style="color:#7e93a6;font-size:0.85rem;">尚無資料，請先按「抓即時匯率」</div>';
                return;
            }
            const toTwd = _fxDirection === 'to_twd';
            if (title) title.innerHTML = toTwd ? '<i class="ic">⇄</i> 各幣 → TWD' : '<i class="ic">⇄</i> TWD → 各幣';
            body.innerHTML = FX_TABLE_CURRENCIES.map(({ code, name, dec }) => {
                const rate = extra[code];
                if (rate == null || rate === 0) return '';
                const value   = toTwd ? rate : 1 / rate;
                const digitsR = toTwd ? (dec > 4 ? 4 : dec) : (value < 0.01 ? 6 : value < 1 ? 4 : 2);
                const display = value.toFixed(digitsR);
                const left    = toTwd ? `1 ${code} <span style="color:#607585;font-size:0.78rem;">(${name})</span>` : `1 TWD`;
                const right   = toTwd ? `${display} <span style="color:#7e93a6;font-size:0.76rem;">TWD</span>` : `${display} <span style="color:#7e93a6;font-size:0.76rem;">${code}</span>`;
                return `<div style="display:flex;align-items:center;justify-content:space-between;gap:1.5rem;padding:0.3rem 0;border-bottom:1px solid rgba(255,255,255,0.05);">
                    <span style="color:#a8bdd0;font-size:0.85rem;white-space:nowrap;">${left}</span>
                    <span class="mono" style="color:#f1f5f9;font-weight:600;font-size:0.9rem;">${right}</span>
                </div>`;
            }).join('');
            if (ts) {
                const t = new Date(ts).toLocaleTimeString('zh-TW', { hour:'2-digit', minute:'2-digit' });
                timeEl.textContent = fromCache ? `快取 ${t}（${_fxAgeStr(ts)}）` : `即時 ${t}`;
                // v15.063：匯率快取年齡套色（TTL 1hr：<30min 新鮮、30-90min 接近過期、>90min 已過期）
                timeEl.style.color = fromCache
                    ? _freshnessColor(Date.now() - ts, 30*60*1000, 90*60*1000)
                    : '#7e93a6';
            }
        }

        function toggleFxDirection() {
            _fxDirection = _fxDirection === 'to_twd' ? 'from_twd' : 'to_twd';
            if (_fxLastData?.extra) _renderFxTable(_fxLastData.extra, _fxLastData.ts, _fxLastData.fromCache);
        }

        async function showFxTable(e) {
            e?.stopPropagation();
            const popup = document.getElementById('fx-table-popup');
            popup.style.display = 'flex';

            // 先用快取渲染（快，無延遲）
            const cached = _loadFxCache();
            if (cached?.extra) {
                _fxLastData = { extra: cached.extra, ts: cached.ts, fromCache: true };
                _renderFxTable(cached.extra, cached.ts, true);
            } else {
                document.getElementById('fx-table-body').innerHTML = '<div style="color:#7e93a6;font-size:0.85rem;">載入中...</div>';
            }

            // 背景靜默更新（快取未過期時直接回傳，不打 API）
            const fx = await _fetchFxRates(false);
            if (fx?.extra) {
                _fxLastData = { extra: fx.extra, ts: fx.ts, fromCache: fx.fromCache };
                _renderFxTable(fx.extra, fx.ts, fx.fromCache);
            }
        }

        async function fetchLiveRates(btn) {
            btn.textContent = '更新中...'; btn.disabled = true;
            try {
                const fx = await _fetchFxRates(true); // 手動觸發 → 強制重新抓取
                if (!fx) throw new Error('API 回傳格式異常或逾時');
                exchangeRates.USD_TWD = fx.USD_TWD;
                exchangeRates.HKD_TWD = fx.HKD_TWD;
                syncRateInputs();
                document.getElementById('rate-source').textContent = '✓ 即時匯率（' + new Date().toLocaleTimeString('zh-TW') + '）';
                renderAll();
            } catch(e) {
                showWarnToast('❌ 無法取得即時匯率：' + e.message);
            } finally {
                btn.textContent = '↻ 抓即時匯率'; btn.disabled = false;
            }
        }

        function syncRateInputs() {
            document.getElementById('input-usd-twd').value = exchangeRates.USD_TWD.toFixed(2);
            document.getElementById('input-hkd-twd').value = exchangeRates.HKD_TWD.toFixed(4);
        }


        function applyReviewedPrices() {
            saveHistory();
            Object.keys(priceReviewData.accepted).forEach(symbol => {
                if (priceReviewData.accepted[symbol]) {
                    const h = holdings.find(item => item.symbol === symbol);
                    if (h) h.currentPrice = priceReviewData.prices[symbol].newPrice;
                }
            });
            hideReviewModal();
            renderAll();
            showImportToast('✅ 已套用選取的股價更新', 2000);
        }
        function hideReviewModal() { document.getElementById('review-modal').style.display = 'none'; priceReviewData = null; }


        // ==================== Tab System ====================
        let _lastAnalysisLoad = 0; // 最後一次載入分析的時間戳

        function switchTab(n) {
            document.querySelectorAll('.tab-pane').forEach(p => p.classList.remove('active'));
            document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
            document.getElementById('tab-pane-' + n).classList.add('active');
            document.getElementById('tab-btn-' + n).classList.add('active');
            const ctrl = document.getElementById('analysis-ctrl');
            if (ctrl) ctrl.style.display = (n === 2 || n === 3) ? 'block' : 'none';

            // 切換到基本面/技術面時自動載入（快取是否有效由 loadAnalysis 內部判斷）
            if ((n === 2 || n === 3) && holdings.length > 0) {
                loadAnalysis(false, false);
            }
            // 切換到財報分析 Tab：首次 或 快取到期（12hr）時重新載入
            if (n === 4 && holdings.length > 0 && (!_earningsLoaded || !_isQsCacheFresh())) {
                loadEarningsAnalysis(false);
            }
            // 切換到總經 Tab：loadMacro 內部判斷快取有效性（1hr TTL）
            if (n === 5) {
                loadMacro(false);
            }
            // 切換到已實現損益 Tab：即時渲染（資料在 tradeHistory，無需 API）
            if (n === 6) {
                renderRealizedTab();
            }
            // 切換到存款 Tab：即時渲染
            if (n === 7) {
                renderDepositsTab();
            }
        }

        // ==================== Leveraged ETF → Underlying Map ====================
        const LEVERAGED_MAP = {
            'NVDL':'NVDA', 'AMDL':'AMD',  'ASTX':'ASTS',  'AVGX':'AVGO',
            'COHX':'COHR', 'FBL':'META',  'GGLL':'GOOGL', 'LITX':'LITE',
            'MUU':'MU',    'NBIG':'NBIS', 'ORCU':'ORCL',  'PLTU':'PLTR',
            'SNXX':'SNDK', 'TSLL':'TSLA', 'TSMX':'TSM',   'WDCX':'WDC',
            'USD':'SOXX',  '7709.HK':'000660.KS', '9747.HK':'005930.KS'
        };
        function getQuerySymbol(symbol) {
            return LEVERAGED_MAP[symbol] || symbol;
        }

        // 掛牌港交所但以美金（USD）計價的 ETF — 損益/市值換算用 USD_TWD，幣別顯示 $
        const HK_USD_PRICED = new Set(['9747.HK']);

        // ==================== KD (Stochastic) Calculation ====================
        function calcKD(highs, lows, closes, period=9) {
            if (!highs || !lows || !closes) return null;
            // filter out null values
            const valid = closes.map((c,i) => c != null && highs[i] != null && lows[i] != null ? i : -1).filter(i => i >= 0);
            const h = valid.map(i => highs[i]);
            const l = valid.map(i => lows[i]);
            const c = valid.map(i => closes[i]);
            if (c.length < period + 3) return null;
            let k = 50, d = 50, prevK = 50, prevD = 50;
            for (let i = period - 1; i < c.length; i++) {
                const hh = Math.max(...h.slice(i - period + 1, i + 1));
                const ll = Math.min(...l.slice(i - period + 1, i + 1));
                const rsv = hh === ll ? 50 : (c[i] - ll) / (hh - ll) * 100;
                prevK = k; prevD = d;
                k = prevK * (2/3) + rsv * (1/3);
                d = prevD * (2/3) + k  * (1/3);
            }
            const crossUp   = prevK <= prevD && k > d;
            const crossDown = prevK >= prevD && k < d;
            return { k: k.toFixed(1), d: d.toFixed(1), crossUp, crossDown };
        }

        function kdBadge(kd) {
            if (!kd) return '<span class="kd-neu">-</span>';
            const label = kd.crossUp ? '▲ 黃金交叉' : kd.crossDown ? '▼ 死亡交叉' : (parseFloat(kd.k) > parseFloat(kd.d) ? 'K>D' : 'K<D');
            const cls   = kd.crossUp ? 'kd-up' : kd.crossDown ? 'kd-down' : 'kd-neu';
            return '<span class="' + cls + '">' + label + '</span><br><small style="color:#7e93a6;font-size:0.75rem;">K:' + kd.k + ' D:' + kd.d + '</small>';
        }

        // ==================== MACD Calculation (12/26/9 EMA) ====================
        function calcMACD(closes) {
            if (!closes) return null;
            const c = closes.filter(v => v != null);
            if (c.length < 35) return null;
            function ema(data, p) {
                const k = 2 / (p + 1);
                let e = data[0];
                return data.map(v => (e = v * k + e * (1 - k)));
            }
            const fast   = ema(c, 12);
            const slow   = ema(c, 26);
            const macdArr = fast.map((v, i) => v - slow[i]);
            const sigArr  = ema(macdArr, 9);
            const n = macdArr.length - 1;
            const macd  = macdArr[n], sig = sigArr[n];
            const pMacd = macdArr[n-1], pSig = sigArr[n-1];
            return {
                macd:     macd.toFixed(3),
                signal:   sig.toFixed(3),
                above:    macd > sig,
                crossUp:  pMacd <= pSig && macd > sig,
                crossDown:pMacd >= pSig && macd < sig
            };
        }

        function macdBadge(m) {
            if (!m) return '<span class="kd-neu">-</span>';
            const label = m.crossUp ? '▲ 黃金交叉' : m.crossDown ? '▼ 死亡交叉' : (m.above ? 'MACD>0' : 'MACD<0');
            const cls   = m.crossUp ? 'kd-up' : m.crossDown ? 'kd-down' : 'kd-neu';
            return '<span class="' + cls + '">' + label + '</span><br><small style="color:#7e93a6;font-size:0.75rem;">M:' + m.macd + ' S:' + m.signal + '</small>';
        }

        // ==================== RSI Calculation (14-period) ====================
        function calcRSI(closes) {
            if (!closes) return null;
            const c = closes.filter(v => v != null);
            if (c.length < 15) return null;
            let gains = 0, losses = 0;
            for (let i = 1; i <= 14; i++) {
                const d = c[i] - c[i-1];
                if (d > 0) gains += d; else losses -= d;
            }
            let ag = gains / 14, al = losses / 14;
            for (let i = 15; i < c.length; i++) {
                const d = c[i] - c[i-1];
                ag = (ag * 13 + Math.max(d, 0)) / 14;
                al = (al * 13 + Math.max(-d, 0)) / 14;
            }
            const rsi = al === 0 ? 100 : 100 - 100 / (1 + ag / al);
            return { rsi: rsi.toFixed(1), overbought: rsi >= 70, oversold: rsi <= 30 };
        }

        function rsiBadge(r) {
            if (!r) return '<span class="rsi-neu">-</span>';
            const cls   = r.overbought ? 'rsi-ob' : r.oversold ? 'rsi-os' : 'rsi-neu';
            const label = r.overbought ? '⚠ 超買' : r.oversold ? '⚡ 超賣' : '中性';
            return '<span class="' + cls + '">' + label + '</span><br><small style="color:#7e93a6;font-size:0.75rem;">RSI:' + r.rsi + '</small>';
        }

        // ==================== 技術面綜合評價 ====================
        function calcTechScore(d) {
            let score = 0;
            const scoreKD = (cross, k, dv, w) => {
                if (k == null) return 0;
                if (cross === 'golden') return w;
                if (cross === 'death')  return -w;
                const kv = parseFloat(k), dv2 = parseFloat(dv);
                return (isNaN(kv)||isNaN(dv2)) ? 0 : (kv > dv2 ? w*0.5 : -w*0.5);
            };
            const scoreMACD = (m, w) => {
                if (!m) return 0;
                if (m.crossUp)   return w;
                if (m.crossDown) return -w;
                return m.above ? w*0.5 : -w*0.5;
            };
            const scoreRSI = (r, w) => {
                if (!r) return 0;
                const ob = typeof r==='object' ? r.overbought : parseFloat(r)>=70;
                const os = typeof r==='object' ? r.oversold   : parseFloat(r)<=30;
                if (ob) return -w*2; if (os) return w*2; return 0;
            };
            score += scoreKD(d.hourly_cross, d.hourly_k, d.hourly_d, 1);
            score += scoreKD(d.daily_cross,  d.daily_k,  d.daily_d,  2);
            score += scoreKD(d.weekly_cross, d.weekly_k, d.weekly_d, 3);
            score += scoreMACD(d.hourly_macd, 1);
            score += scoreMACD(d.daily_macd,  2);
            score += scoreMACD(d.weekly_macd, 3);
            score += scoreRSI(d.hourly_rsi, 1);
            score += scoreRSI(d.daily_rsi,  2);
            score += scoreRSI(d.weekly_rsi, 3);
            return score;
        }

        function techSummaryBadge(d) {
            const score = calcTechScore(d);
            const s = score.toFixed(1);
            const small = '<br><small style="color:#7e93a6;font-size:0.72rem;">分數:' + s + '</small>';
            if (score >= 10) return '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:rgba(16,185,129,0.2);color:#10b981;font-weight:700;">⬆ 強烈買進</span>' + small;
            if (score >= 4)  return '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:rgba(16,185,129,0.1);color:#6ee7b7;font-weight:700;">↑ 建議買進</span>' + small;
            if (score >= -4) return '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:rgba(100,116,139,0.15);color:#a8bdd0;font-weight:700;">→ 中性觀望</span>' + small;
            if (score >= -10)return '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:rgba(251,146,60,0.15);color:#fb923c;font-weight:700;">↓ 建議賣出</span>' + small;
            return '<span style="padding:0.2rem 0.5rem;border-radius:6px;background:rgba(239,68,68,0.18);color:#ef4444;font-weight:700;">⬇ 強烈賣出</span>' + small;
        }

        // ==================== 後端設定 ====================
        // 本機開發：空字串（相對路徑 /proxy, /yfundamentals）
        // GitHub Pages：填入 Render.com 的網址，例如 https://portfolio-tracker-api.onrender.com
        const BACKEND_URL = (() => {
            const h = window.location.hostname;
            if (h === 'localhost' || h === '127.0.0.1') return '';   // 本機
            // GitHub Pages → 使用儲存的後端網址，或提示設定
            return localStorage.getItem('backend_url') || '';
        })();

        // ==================== Yahoo Finance fetch via CORS proxy ====================
        const _isLocal = (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
        const YF_PROXIES = [
            // 嘗試直接存取（Yahoo 有時允許 CORS）
            u => u,
            // 本機後端或已設定後端才啟用
            ...(_isLocal || BACKEND_URL ? [u => (BACKEND_URL || '') + '/proxy?url=' + encodeURIComponent(u)] : []),
            u => 'https://api.allorigins.win/raw?url='             + encodeURIComponent(u),
            u => 'https://api.codetabs.com/v1/proxy?quest='        + encodeURIComponent(u),
            u => 'https://corsproxy.io/?'                          + encodeURIComponent(u),
        ];

        // 記住上次成功的 proxy 索引（頁面週期內有效），避免每次都從第一個重試
        let _yfProxyIdx = 0;

        // 根據標的代碼回傳對應交易所時區（用於判斷「今天有沒有開盤」）
        function _exchangeTz(symbol) {
            if (symbol.endsWith('.TW')) return 'Asia/Taipei';
            if (symbol.endsWith('.HK')) return 'Asia/Hong_Kong';
            return 'America/New_York';
        }

        async function yfFetch(url) {
            const errors = [];
            const n = YF_PROXIES.length;
            for (let attempt = 0; attempt < n; attempt++) {
                const idx = (_yfProxyIdx + attempt) % n;
                const mkProxy = YF_PROXIES[idx];
                const ctrl = new AbortController();
                // 超時從 12s 縮短至 5s，失敗時可更快切換到下一個 proxy
                const tid  = setTimeout(() => ctrl.abort(), 5000);
                try {
                    const res  = await fetch(mkProxy(url), { signal: ctrl.signal });
                    clearTimeout(tid);
                    if (!res.ok) throw new Error('HTTP ' + res.status);
                    const text = await res.text();
                    // 確認是 JSON（proxy 可能回傳 HTML 錯誤頁）
                    if (!text.trimStart().startsWith('{') && !text.trimStart().startsWith('['))
                        throw new Error('非 JSON 回應');
                    _yfProxyIdx = idx; // 記住成功的 proxy，下次直接從這裡開始
                    return JSON.parse(text);
                } catch(e) {
                    clearTimeout(tid);
                    errors.push(e.message);
                }
            }
            throw new Error('所有代理均失敗（' + errors.join('；') + '）');
        }

        // #endregion Gist Silent Pull
        // #endregion Gist Sync

        // ════════════════════════════════════════════════════════════════════
        // v15.077：本地資料夾同步（File System Access API）— 桌機限定，獨立於 Gist
        // 設計約束：GIST 已設定時 hard reject FSA；不共用 Gist 函式 / dirty domain / pending count
        // ════════════════════════════════════════════════════════════════════
        // #region Local Sync (FSA, desktop-only, independent from Gist)

        // ── IndexedDB helpers — 存 FileSystemDirectoryHandle（unserializable，不能用 localStorage）
        // v15.079：DB version 升 1→2，新增 'rollbacks' store 給 master flag 回復點使用；既有 'handles' store 不動
        const PT_IDB_NAME         = 'pt_idb_v1';
        const PT_IDB_STORE        = 'handles';
        const PT_IDB_ROLLBACK_STORE = 'rollbacks';
        const PT_IDB_VERSION      = 2;
        const PT_IDB_SYNC_DIR_KEY = 'syncDir';
        function _idbOpen() {
            return new Promise((resolve, reject) => {
                if (typeof indexedDB === 'undefined') return reject(new Error('IndexedDB not available'));
                const req = indexedDB.open(PT_IDB_NAME, PT_IDB_VERSION);
                req.onupgradeneeded = (ev) => {
                    const db = req.result;
                    const oldV = ev.oldVersion || 0;
                    if (!db.objectStoreNames.contains(PT_IDB_STORE)) db.createObjectStore(PT_IDB_STORE);
                    if (oldV < 2 && !db.objectStoreNames.contains(PT_IDB_ROLLBACK_STORE)) {
                        db.createObjectStore(PT_IDB_ROLLBACK_STORE);
                    }
                };
                req.onsuccess = () => {
                    const db = req.result;
                    // v15.079：他 tab 開新版升級時讓本連線釋放，避免 block
                    db.onversionchange = () => { try { db.close(); } catch(_) {} };
                    resolve(db);
                };
                req.onerror   = () => reject(req.error);
                req.onblocked = () => console.warn('[IDB] open blocked — 其他 tab 仍開著舊版 DB，請關閉重試');
            });
        }
        async function _idbPut(key, val) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_STORE, 'readwrite');
                    tx.objectStore(PT_IDB_STORE).put(val, key);
                    tx.oncomplete = () => { db.close(); resolve(true); };
                    tx.onerror    = () => { db.close(); reject(tx.error); };
                });
            } catch(e) {
                console.warn('[LocalSync] IDB put failed:', e?.message);
                return false;
            }
        }
        async function _idbGet(key) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_STORE, 'readonly');
                    const r  = tx.objectStore(PT_IDB_STORE).get(key);
                    r.onsuccess = () => { db.close(); resolve(r.result); };
                    r.onerror   = () => { db.close(); reject(r.error); };
                });
            } catch(e) {
                console.warn('[LocalSync] IDB get failed:', e?.message);
                return null;
            }
        }
        async function _idbDelete(key) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_STORE, 'readwrite');
                    tx.objectStore(PT_IDB_STORE).delete(key);
                    tx.oncomplete = () => { db.close(); resolve(true); };
                    tx.onerror    = () => { db.close(); reject(tx.error); };
                });
            } catch(_) { return false; }
        }
        // v15.079：rollback store helpers（key = masterId）
        async function _idbSaveRollback(masterId, obj) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_ROLLBACK_STORE, 'readwrite');
                    tx.objectStore(PT_IDB_ROLLBACK_STORE).put(obj, masterId);
                    tx.oncomplete = () => { db.close(); resolve(true); };
                    tx.onerror    = () => { db.close(); reject(tx.error); };
                });
            } catch(e) {
                console.warn('[Rollback] IDB save failed:', e?.message);
                return false;
            }
        }
        async function _idbGetRollback(masterId) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_ROLLBACK_STORE, 'readonly');
                    const r  = tx.objectStore(PT_IDB_ROLLBACK_STORE).get(masterId);
                    r.onsuccess = () => { db.close(); resolve(r.result || null); };
                    r.onerror   = () => { db.close(); reject(r.error); };
                });
            } catch(e) {
                console.warn('[Rollback] IDB get failed:', e?.message);
                return null;
            }
        }
        async function _idbDeleteRollback(masterId) {
            try {
                const db = await _idbOpen();
                return await new Promise((resolve, reject) => {
                    const tx = db.transaction(PT_IDB_ROLLBACK_STORE, 'readwrite');
                    tx.objectStore(PT_IDB_ROLLBACK_STORE).delete(masterId);
                    tx.oncomplete = () => { db.close(); resolve(true); };
                    tx.onerror    = () => { db.close(); reject(tx.error); };
                });
            } catch(_) { return false; }
        }

        // ── basic predicates
        // v15.078 hotfix：FSA 真正限定桌機（擋 mobile UA / secureContext / IDB 三層），避免 Android Chrome 走 FSA 路徑卡住 UI
        function _isFsaSupported() {
            if (typeof window.showDirectoryPicker !== 'function') return false;
            if (typeof window.isSecureContext !== 'undefined' && !window.isSecureContext) return false;
            if (typeof indexedDB === 'undefined') return false;
            try {
                const ua = navigator.userAgent || '';
                if (/Android|iPhone|iPad|iPod|Mobile|webOS|BlackBerry|IEMobile|Opera Mini/i.test(ua)) return false;
            } catch(_) {}
            return true;
        }
        // v15.078：除了 localStorage，也納入目前輸入框 token / id，避免 user 填完但還沒按 push 時被 FSA 路徑誤觸
        function _hasGistCreds() {
            const lsToken = localStorage.getItem(GIST_TOKEN_KEY) || '';
            const lsId    = localStorage.getItem(GIST_ID_KEY)    || '';
            if (lsToken && lsId) return true;
            try {
                const inToken = (document.getElementById('gist-token')?.value || '').trim();
                const inId    = (document.getElementById('gist-id')?.value || '').trim();
                return !!inToken && !!inId;
            } catch(_) { return false; }
        }
        function _isLocalSyncEnabled() {
            return !_hasGistCreds()
                && _isFsaSupported()
                && localStorage.getItem(STORAGE_KEYS.localSyncEnabled) === '1';
        }
        function _getLocalSyncDeviceId() {
            let id = localStorage.getItem(STORAGE_KEYS.localSyncDeviceId);
            if (!id) {
                try {
                    id = (typeof crypto !== 'undefined' && crypto.randomUUID)
                        ? crypto.randomUUID()
                        : ('dev-' + Math.random().toString(36).slice(2) + Date.now().toString(36));
                } catch(_) {
                    id = 'dev-' + Math.random().toString(36).slice(2) + Date.now().toString(36);
                }
                localStorage.setItem(STORAGE_KEYS.localSyncDeviceId, id);
            }
            return id;
        }
        function _getLocalSyncFileName() {
            return localStorage.getItem(STORAGE_KEYS.localSyncFile) || 'portfolio-tracker.json';
        }
        function _readLocalSyncDirty() {
            try {
                const arr = JSON.parse(localStorage.getItem(STORAGE_KEYS.localSyncDirtyDomains) || '[]');
                return Array.isArray(arr) ? arr : [];
            } catch(_) { return []; }
        }
        function _writeLocalSyncDirty(arr) {
            if (Array.isArray(arr) && arr.length > 0) {
                localStorage.setItem(STORAGE_KEYS.localSyncDirtyDomains, JSON.stringify(arr));
            } else {
                localStorage.removeItem(STORAGE_KEYS.localSyncDirtyDomains);
            }
        }
        function _markLocalSyncModified(domains) {
            // FSA 自己的 dirty domains，跟 Gist 完全獨立；GIST 已設或 FSA 沒啟用都 noop
            if (_isApplyingCloudPull) return;
            if (_hasGistCreds()) return;
            if (!_isLocalSyncEnabled()) return;
            const ts = new Date().toISOString();
            localStorage.setItem(STORAGE_KEYS.localSyncLocalModifiedAt, ts);
            const set = new Set(_readLocalSyncDirty());
            (Array.isArray(domains) ? domains : [domains]).forEach(d => { if (d) set.add(d); });
            _writeLocalSyncDirty([...set]);
        }
        function _clearLocalSyncDirty() {
            _writeLocalSyncDirty([]);
            localStorage.removeItem(STORAGE_KEYS.localSyncLocalModifiedAt);
        }

        // ── permission helpers
        async function _localSyncGetDirNoPrompt() {
            const handle = await _idbGet(PT_IDB_SYNC_DIR_KEY);
            if (!handle) return null;
            try {
                const perm = await handle.queryPermission({ mode: 'readwrite' });
                return perm === 'granted' ? handle : null;
            } catch(_) { return null; }
        }
        async function _localSyncRequestPermissionOnGesture() {
            const handle = await _idbGet(PT_IDB_SYNC_DIR_KEY);
            if (!handle) return null;
            try {
                const perm = await handle.queryPermission({ mode: 'readwrite' });
                if (perm === 'granted') return handle;
                const r = await handle.requestPermission({ mode: 'readwrite' });
                return r === 'granted' ? handle : null;
            } catch(_) { return null; }
        }
        async function _localSyncPickDir() {
            if (_hasGistCreds()) {
                showWarnToast('Gist 已啟用，請先停用 Gist 才能改用本地同步', 3500);
                return;
            }
            if (!_isFsaSupported()) {
                showWarnToast('此瀏覽器不支援 File System Access API（請用桌機 Chrome / Edge，或改用 Gist）', 4000);
                return;
            }
            try {
                const handle = await window.showDirectoryPicker({ id: 'portfolio-tracker', mode: 'readwrite' });
                const ok = await _idbPut(PT_IDB_SYNC_DIR_KEY, handle);
                if (!ok) {
                    showWarnToast('IndexedDB 不可用（無痕模式或被禁用），無法保存資料夾授權', 4000);
                    return;
                }
                localStorage.setItem(STORAGE_KEYS.localSyncDirName, handle.name || '(未命名資料夾)');
                localStorage.setItem(STORAGE_KEYS.localSyncEnabled, '1');
                _getLocalSyncDeviceId();   // 第一次啟用順手生成 device id
                _setLocalSyncStatus(`已啟用：${handle.name}`, '#10b981');
                _renderLocalSyncStatus();
            } catch(e) {
                if (e?.name !== 'AbortError') {
                    console.warn('[LocalSync] pickDir failed:', e?.message);
                    showWarnToast(`選擇資料夾失敗：${e?.message || e}`, 3500);
                }
            }
        }
        async function _localSyncDisable() {
            localStorage.setItem(STORAGE_KEYS.localSyncEnabled, '0');
            await _idbDelete(PT_IDB_SYNC_DIR_KEY);
            localStorage.removeItem(STORAGE_KEYS.localSyncDirName);
            localStorage.removeItem(STORAGE_KEYS.localSyncBasePushedAt);
            localStorage.removeItem(STORAGE_KEYS.localSyncLocalModifiedAt);
            localStorage.removeItem(STORAGE_KEYS.localSyncDirtyDomains);
            localStorage.removeItem(STORAGE_KEYS.localSyncLastPushAt);
            localStorage.removeItem(STORAGE_KEYS.localSyncLastPullAt);
            localStorage.removeItem(STORAGE_KEYS.localSyncLastError);
            // localSyncDeviceId 保留（重新啟用沿用同一 device id）
            _setLocalSyncStatus('已停用', '#7e93a6');
            _renderLocalSyncStatus();
            showImportToast('已停用本地資料夾同步', 1800);
        }

        // ── payload build / validate / apply
        function _buildLocalSyncPayload() {
            const pushedAt = new Date().toISOString();
            return {
                schema_version: PT_SCHEMA_VERSION,
                app_version:    APP_VERSION,
                pushedAt,
                sync_source:    'local_fsa',
                local_sync_meta: {
                    payload_version: 1,
                    deviceId:        _getLocalSyncDeviceId(),
                    basePushedAt:    localStorage.getItem(STORAGE_KEYS.localSyncBasePushedAt) || '',
                    dirtyDomains:    _readLocalSyncDirty(),
                    fileName:        _getLocalSyncFileName()
                },
                holdings,
                watchlist,
                tradeHistory,
                deposits,
                marketSnapshots,
                daily_pnl_snapshots: _loadDailyPnlSnapshots(),
                currency,
                exchangeRates,
                sheet_url:    document.getElementById('sheet-url')?.value?.trim() || '',
                cash_pie_cb:   document.getElementById('cash-pie-cb')?.checked  || false,
                crypto_twd:    parseFloat(document.getElementById('crypto-twd-input')?.value) || 0,
                crypto_pie_cb: document.getElementById('crypto-pie-cb')?.checked || false,
                moxa_twd:      parseFloat(document.getElementById('moxa-twd-input')?.value)   || 0,
                moxa_pie_cb:   document.getElementById('moxa-pie-cb')?.checked   || false
            };
        }
        function _validateLocalSyncPayload(saved) {
            if (!saved || typeof saved !== 'object') return { ok: false, reason: '檔案不是合法 JSON 物件' };
            if (!Array.isArray(saved.holdings)) return { ok: false, reason: 'holdings 欄位缺失或不是 array' };
            const sv = saved.schema_version;
            if (sv != null && Number(sv) > Number(PT_SCHEMA_VERSION)) {
                return { ok: false, reason: `Schema 版本 v${sv} 高於本機 v${PT_SCHEMA_VERSION}，請先更新 PWA` };
            }
            if (saved.pushedAt && isNaN(new Date(saved.pushedAt).getTime())) {
                return { ok: false, reason: 'pushedAt 不是合法時間' };
            }
            if (saved.sync_source != null && saved.sync_source !== 'local_fsa' && saved.sync_source !== '') {
                return { ok: false, reason: `sync_source 非預期：${saved.sync_source}` };
            }
            for (const k of ['watchlist','tradeHistory','deposits','marketSnapshots']) {
                if (saved[k] != null && !Array.isArray(saved[k])) {
                    return { ok: false, reason: `${k} 欄位存在但不是 array` };
                }
            }
            if (saved.daily_pnl_snapshots != null) {
                if (typeof saved.daily_pnl_snapshots !== 'object'
                 || !saved.daily_pnl_snapshots.markets
                 || typeof saved.daily_pnl_snapshots.markets !== 'object') {
                    return { ok: false, reason: 'daily_pnl_snapshots 結構不符' };
                }
            }
            return { ok: true };
        }
        function _applyLocalSyncPayload(saved) {
            // 套用前後 _isApplyingCloudPull = true 防 dirty 反彈（與 Gist pull 共用 flag，但 FSA 自己的 dirty 用 _markLocalSyncModified）
            _isApplyingCloudPull = true;
            try {
                holdings = saved.holdings;
                holdings.forEach(h => { h.persist = true; _ensureLots(h); });
                if (saved.currency)      currency = saved.currency;
                if (saved.exchangeRates) { exchangeRates = saved.exchangeRates; syncRateInputs(); }
                if (saved.sheet_url) {
                    const sheetEl = document.getElementById('sheet-url');
                    if (sheetEl) sheetEl.value = saved.sheet_url;
                    saveSheetUrlSetting();
                }
                deposits = Array.isArray(saved.deposits) ? saved.deposits : [];
                saveDeposits();
                if (saved.cash_pie_cb != null) {
                    localStorage.setItem(PT_CASH_PIE_KEY, saved.cash_pie_cb ? '1' : '0');
                    const cb = document.getElementById('cash-pie-cb'); if (cb) cb.checked = !!saved.cash_pie_cb;
                }
                if (saved.crypto_twd != null) {
                    const v = saved.crypto_twd || 0;
                    if (v > 0) localStorage.setItem(PT_CRYPTO_KEY, v); else localStorage.removeItem(PT_CRYPTO_KEY);
                    const el = document.getElementById('crypto-twd-input'); if (el) el.value = v > 0 ? v : '';
                }
                if (saved.crypto_pie_cb != null) {
                    localStorage.setItem(PT_CRYPTO_PIE_KEY, saved.crypto_pie_cb ? '1' : '0');
                    const cb = document.getElementById('crypto-pie-cb'); if (cb) cb.checked = !!saved.crypto_pie_cb;
                }
                if (saved.moxa_twd != null) {
                    const v = saved.moxa_twd || 0;
                    if (v > 0) localStorage.setItem(PT_MOXA_KEY, v); else localStorage.removeItem(PT_MOXA_KEY);
                    const el = document.getElementById('moxa-twd-input'); if (el) el.value = v > 0 ? v : '';
                }
                if (saved.moxa_pie_cb != null) {
                    localStorage.setItem(PT_MOXA_PIE_KEY, saved.moxa_pie_cb ? '1' : '0');
                    const cb = document.getElementById('moxa-pie-cb'); if (cb) cb.checked = !!saved.moxa_pie_cb;
                }
                if (Array.isArray(saved.watchlist)) { watchlist = saved.watchlist; saveWatchlist(); renderWatchlist(); }
                tradeHistory = Array.isArray(saved.tradeHistory) ? saved.tradeHistory : [];
                saveTradeHistory();
                if (Array.isArray(saved.marketSnapshots)) { marketSnapshots = saved.marketSnapshots; saveSnapshots(); }
                try {
                    if (saved.daily_pnl_snapshots && saved.daily_pnl_snapshots.markets) {
                        const merged = _mergeDailyPnlSnapshots(_loadDailyPnlSnapshots(), saved.daily_pnl_snapshots);
                        _saveDailyPnlSnapshots(merged);
                    }
                } catch(_) {}
                saveToStorage();
                try { _hydrateDailyPnlCachesFromAnalysisCache(); } catch(_) {}
                renderAll();
            } finally {
                _isApplyingCloudPull = false;
            }
        }

        // ── push / pull
        let _localSyncPushTimer = null;
        function _scheduleLocalSyncPush() {
            // 沒啟用 FSA 自動 noop；GIST 設了也自動 noop
            if (!_isLocalSyncEnabled()) return;
            clearTimeout(_localSyncPushTimer);
            _localSyncPushTimer = setTimeout(() => { _localSyncPush({ manual: false }).catch(_ => {}); }, 2000);
        }
        async function _localSyncPush({ manual = false, force = false } = {}) {
            if (_hasGistCreds()) {
                if (manual) showWarnToast('Gist 已啟用，請先停用 Gist 才能用本地同步', 3500);
                return false;
            }
            if (!_isLocalSyncEnabled()) {
                if (manual) showWarnToast('本地同步未啟用，請先選擇資料夾', 3000);
                return false;
            }
            const handle = manual
                ? await _localSyncRequestPermissionOnGesture()   // 手動可 prompt
                : await _localSyncGetDirNoPrompt();              // 自動不 prompt
            if (!handle) {
                if (manual) {
                    _setLocalSyncStatus('⚠ 需要重新授權資料夾', '#fbbf24');
                    showWarnToast('需要授權才能寫入資料夾', 3000);
                }
                return false;
            }
            try {
                const fileName = _getLocalSyncFileName();
                // 衝突偵測：讀檔現存 pushedAt vs 本機 basePushedAt
                let existing = null;
                try {
                    const existingFh = await handle.getFileHandle(fileName, { create: false });
                    const f = await existingFh.getFile();
                    const t = await f.text();
                    existing = JSON.parse(t);
                } catch(_) { /* 檔不存在或損壞，當作首次 push */ }
                if (existing && !force) {
                    const base = localStorage.getItem(STORAGE_KEYS.localSyncBasePushedAt) || '';
                    const remoteTs = existing.pushedAt || '';
                    if (base && remoteTs && remoteTs !== base) {
                        // 檔案被他裝置 push 過 → conflict
                        const msg = `同步檔已被他處更新（${remoteTs}），與本機基準（${base}）不符`;
                        localStorage.setItem(STORAGE_KEYS.localSyncLastError, msg);
                        if (manual) {
                            const ok = confirm(`${msg}\n\n按確定 = 強制覆蓋同步檔（建議先點「拉取」確認他處變更）\n按取消 = 中止`);
                            if (!ok) {
                                _setLocalSyncStatus('❌ 衝突：手動取消推送', '#ef4444');
                                return false;
                            }
                            return _localSyncPush({ manual: true, force: true });
                        } else {
                            _setLocalSyncStatus('❌ 衝突：手動處理（拉取或強制推送）', '#ef4444');
                            return false;
                        }
                    }
                }
                const payload = _buildLocalSyncPayload();
                const fileHandle = await handle.getFileHandle(fileName, { create: true });
                const writable = await fileHandle.createWritable();
                await writable.write(JSON.stringify(payload, null, 2));
                await writable.close();
                localStorage.setItem(STORAGE_KEYS.localSyncBasePushedAt, payload.pushedAt);
                localStorage.setItem(STORAGE_KEYS.localSyncLastPushAt,   payload.pushedAt);
                localStorage.removeItem(STORAGE_KEYS.localSyncLastError);
                _clearLocalSyncDirty();
                _setLocalSyncStatus(`✅ 已推送${force?'（強制覆蓋）':''}`, '#10b981');
                _renderLocalSyncStatus();
                return true;
            } catch(e) {
                const msg = e?.message || String(e);
                localStorage.setItem(STORAGE_KEYS.localSyncLastError, msg);
                try { _recordAppError && _recordAppError('local_sync_push', e); } catch(_) {}
                _setLocalSyncStatus(`❌ 推送失敗：${msg}`, '#ef4444');
                if (manual) showWarnToast(`本地推送失敗：${msg}`, 4000);
                return false;
            }
        }
        async function _localSyncPull({ manual = false } = {}) {
            if (_hasGistCreds()) {
                if (manual) showWarnToast('Gist 已啟用，請先停用 Gist 才能用本地同步', 3500);
                return false;
            }
            if (!_isLocalSyncEnabled()) {
                if (manual) showWarnToast('本地同步未啟用，請先選擇資料夾', 3000);
                return false;
            }
            const handle = manual
                ? await _localSyncRequestPermissionOnGesture()
                : await _localSyncGetDirNoPrompt();
            if (!handle) {
                if (manual) {
                    _setLocalSyncStatus('⚠ 需要重新授權資料夾', '#fbbf24');
                    showWarnToast('需要授權才能讀取資料夾', 3000);
                }
                return false;
            }
            try {
                const fileName = _getLocalSyncFileName();
                let fileHandle;
                try { fileHandle = await handle.getFileHandle(fileName, { create: false }); }
                catch {
                    if (manual) showWarnToast(`找不到 ${fileName}`, 3000);
                    _setLocalSyncStatus('檔案尚未建立', '#7e93a6');
                    return false;
                }
                const file = await fileHandle.getFile();
                const text = await file.text();
                let saved;
                try { saved = JSON.parse(text); }
                catch(e) {
                    const msg = `${fileName} 不是合法 JSON：${e.message}`;
                    localStorage.setItem(STORAGE_KEYS.localSyncLastError, msg);
                    try { _recordAppError && _recordAppError('local_sync_pull', e); } catch(_) {}
                    _setLocalSyncStatus(`❌ ${msg}`, '#ef4444');
                    if (manual) showWarnToast(msg, 4000);
                    return false;
                }
                const v = _validateLocalSyncPayload(saved);
                if (!v.ok) {
                    const msg = `驗證失敗：${v.reason}`;
                    localStorage.setItem(STORAGE_KEYS.localSyncLastError, msg);
                    try { _recordAppError && _recordAppError('local_sync_pull', new Error(msg)); } catch(_) {}
                    _setLocalSyncStatus(`❌ ${msg}`, '#ef4444');
                    if (manual) showWarnToast(msg, 4000);
                    return false;
                }
                if (saved.holdings.length === 0 && holdings.length > 0 && !manual) {
                    // 自動 pull 不要把空檔覆蓋有資料的本機（保護 — 手動 pull 不擋）
                    return false;
                }
                _applyLocalSyncPayload(saved);
                if (saved.pushedAt) localStorage.setItem(STORAGE_KEYS.localSyncBasePushedAt, saved.pushedAt);
                localStorage.setItem(STORAGE_KEYS.localSyncLastPullAt, new Date().toISOString());
                localStorage.removeItem(STORAGE_KEYS.localSyncLastError);
                _clearLocalSyncDirty();
                _setLocalSyncStatus(`✅ 已從本地同步檔載入`, '#10b981');
                _renderLocalSyncStatus();
                if (manual) showImportToast(`✅ 已從 ${fileName} 載入 ${holdings.length} 筆持倉`, 2500);
                return true;
            } catch(e) {
                const msg = e?.message || String(e);
                localStorage.setItem(STORAGE_KEYS.localSyncLastError, msg);
                try { _recordAppError && _recordAppError('local_sync_pull', e); } catch(_) {}
                _setLocalSyncStatus(`❌ 拉取失敗：${msg}`, '#ef4444');
                if (manual) showWarnToast(`本地拉取失敗：${msg}`, 4000);
                return false;
            }
        }

        // ── UI status
        function _setLocalSyncStatus(text, color) {
            const el = document.getElementById('local-sync-status');
            if (el) { el.textContent = text; el.style.color = color || '#607585'; }
        }
        function _renderLocalSyncStatus() {
            const card     = document.getElementById('local-sync-card');
            const pickBtn  = document.getElementById('local-sync-pick-btn');
            const pushBtn  = document.getElementById('local-sync-push-btn');
            const pullBtn  = document.getElementById('local-sync-pull-btn');
            const offBtn   = document.getElementById('local-sync-off-btn');
            const dirNameEl= document.getElementById('local-sync-dir-name');
            if (!card) return;
            if (_hasGistCreds()) {
                // v15.078：取消整張 pointer-events:none，三個 sync 按鈕個別 disabled，但「停用」仍可點
                // 讓誤啟用 FSA 的 user 能關掉 FSA 設定
                card.style.opacity = '0.7';
                card.style.pointerEvents = '';
                if (pickBtn) pickBtn.disabled = true;
                if (pushBtn) pushBtn.disabled = true;
                if (pullBtn) pullBtn.disabled = true;
                if (offBtn)  offBtn.disabled  = false;
                _setLocalSyncStatus('Gist 已啟用，本地同步停用（可點下方「停用本地同步」清除 FSA 設定）', '#7e93a6');
                if (dirNameEl) dirNameEl.textContent = '';
                return;
            }
            card.style.opacity = '1';
            card.style.pointerEvents = '';
            if (!_isFsaSupported()) {
                // v15.078：手機 / 不支援 FSA 的瀏覽器，所有按鈕 disable（含 offBtn — 沒設過就不需要停用）
                if (pickBtn) pickBtn.disabled = true;
                if (pushBtn) pushBtn.disabled = true;
                if (pullBtn) pullBtn.disabled = true;
                if (offBtn)  offBtn.disabled  = true;
                _setLocalSyncStatus('瀏覽器不支援（請用桌機 Chrome / Edge，或改用 Gist）', '#fbbf24');
                if (dirNameEl) dirNameEl.textContent = '';
                return;
            }
            const enabled = localStorage.getItem(STORAGE_KEYS.localSyncEnabled) === '1';
            const dirName = localStorage.getItem(STORAGE_KEYS.localSyncDirName) || '';
            if (dirNameEl) dirNameEl.textContent = enabled && dirName ? `資料夾：${dirName}` : '';
            if (!enabled) {
                _setLocalSyncStatus('未啟用', '#7e93a6');
                if (pushBtn) pushBtn.disabled = true;
                if (pullBtn) pullBtn.disabled = true;
                if (offBtn)  offBtn.disabled  = true;
                return;
            }
            if (pushBtn) pushBtn.disabled = false;
            if (pullBtn) pullBtn.disabled = false;
            if (offBtn)  offBtn.disabled  = false;
            const lastPush = localStorage.getItem(STORAGE_KEYS.localSyncLastPushAt) || '';
            const lastPull = localStorage.getItem(STORAGE_KEYS.localSyncLastPullAt) || '';
            const lastErr  = localStorage.getItem(STORAGE_KEYS.localSyncLastError)  || '';
            const fmt = ts => ts ? new Date(ts).toLocaleString('zh-TW', { hour:'2-digit', minute:'2-digit', month:'2-digit', day:'2-digit' }) : '—';
            if (lastErr) {
                _setLocalSyncStatus(`❌ ${lastErr.slice(0,80)}`, '#ef4444');
            } else {
                _setLocalSyncStatus(`已啟用｜推送 ${fmt(lastPush)}｜拉取 ${fmt(lastPull)}`, '#10b981');
            }
        }

        // #endregion Local Sync

        // #region Analysis Data (fundamentals.json + Yahoo chart)
        async function fetchSymbolDataFromYahoo(symbol) {
            const BASE1    = 'https://query1.finance.yahoo.com';
            const fundBase = BACKEND_URL || '';

            // 外層變數：讓 ①②③ 三個步驟共用同一組基本面數值
            let fund = {};
            let pe = null, fpe = null, peg = null, ps = null;
            let eps_ttm = null, eps_cur_q = null, eps_next_q = null, eps_cur_y = null, eps_next_y = null;
            let _jsonHasTech = false; // JSON 是否含技術面

            // ══════════════════════════════════════════════════════════════════
            // ① 優先讀 data/fundamentals.json（本機 & GitHub Pages 都用同一份）
            //    確保兩端數字完全一致；新標的不在 JSON 才走後面的 API 路徑。
            // ══════════════════════════════════════════════════════════════════
            try {
                if (!window._fundJsonCache) {
                    // cache:'no-cache' → 強制驗證伺服器端是否有新版本（ETag/Last-Modified），
                    // 確保 GitHub Actions 每次推送的新 fundamentals.json 不被瀏覽器舊快取覆蓋
                    try {
                        const r = await fetch('./data/fundamentals.json', { cache: 'no-store' });
                        if (r.ok) {
                            // Python 的 JSON 序列化可能包含 NaN/Infinity（非標準 JSON），需先替換為 null
                            const txt = await r.text();
                            const cleaned = txt.replace(/:\s*NaN/g, ': null')
                                               .replace(/:\s*Infinity/g, ': null')
                                               .replace(/:\s*-Infinity/g, ': null');
                            window._fundJsonCache = JSON.parse(cleaned);
                        } else {
                            window._fundJsonCache = null; // 失敗設 null（非 {}），讓下次進來可重試
                            // v15.064：記錄 HTTP 失敗
                            const e = new Error('HTTP ' + r.status);
                            e.status = r.status;
                            _recordAppError('fundamentals_json_load', e);
                        }
                    } catch (fetchErr) {
                        // v15.064：記錄 fetch / parse 例外
                        window._fundJsonCache = null;
                        _recordAppError('fundamentals_json_load', fetchErr);
                    }
                }
                const f = window._fundJsonCache?.data?.[symbol];
                if (f && !f.error) {
                    // 把基本面寫入外層變數（無論有無技術面都先存）
                    fund       = f;
                    pe         = f.pe         ?? null;
                    fpe        = f.fpe        ?? null;
                    peg        = f.peg        ?? null;
                    ps         = f.ps         ?? null;
                    eps_ttm    = f.eps_ttm    ?? null;
                    eps_cur_q  = f.eps_cur_q  ?? f.eps_next_q ?? null; // 相容舊版 JSON
                    eps_next_q = f.eps_next_q2 ?? null;
                    eps_cur_y  = f.eps_cur_y  ?? null;
                    eps_next_y = f.eps_next_y ?? null;
                    const next_earnings_date    = f.next_earnings_date    ?? null;
                    const no_earnings           = f.no_earnings           === true;
                    const earnings_proxy_symbol = f.earnings_proxy_symbol ?? null;

                    // fundamentals.json 有此標的 → 直接返回，技術面若為 null 顯示 -
                    {
                        _jsonHasTech = true;
                        let prevClose     = f.prev_close      ?? null;
                        let prevPrevClose = f.prev_prev_close ?? null;
                        let marketOpenedToday = null; // 預設未知

                        // JSON 缺 prevClose（舊版 JSON 或 yfinance 未回傳）→ 快速抓 5-day chart 補充
                        if (prevClose == null) {
                            try {
                                const qd  = await yfFetch(`${BASE1}/v8/finance/chart/${symbol}?interval=1d&range=5d`);
                                const ch  = qd?.chart?.result?.[0];
                                const tss = ch?.timestamp ?? [];
                                // v15.080 後續修補：zip + filter 對齊 timestamp 與 close（盤中 close=null 時不能只 filter 一邊）
                                // 否則 tss[last] 仍指向今天但 closes 已少一筆 → opened 誤判 true → prevClose 取 closes[len-2] 變「真前一交易日」→ 兩倍漲幅 bug
                                const _pairs = (ch?.indicators?.quote?.[0]?.close ?? []).map((cv, i) => ({ ts: tss[i], close: cv })).filter(p => p.close != null);
                                if (_pairs.length === 0) throw new Error('no chart data');
                                const c = _pairs.map(p => p.close);
                                const _tz0 = _exchangeTz(symbol);
                                const todayET = new Date().toLocaleDateString('en-US', {timeZone:_tz0});
                                const barET   = new Date(_pairs[_pairs.length-1].ts * 1000).toLocaleDateString('en-US',{timeZone:_tz0});
                                marketOpenedToday = (todayET === barET);
                                // 去除 Yahoo 在未開盤時附加的幻影重複 bar（closes[-1]=closes[-2] 完全相等）
                                const adjC = c.slice();
                                if (!marketOpenedToday) {
                                    while (adjC.length >= 2 && adjC[adjC.length-1] === adjC[adjC.length-2]) adjC.pop();
                                }
                                if (marketOpenedToday) {
                                    if (adjC.length >= 2) prevClose     = adjC[adjC.length - 2];
                                    if (adjC.length >= 3) prevPrevClose = adjC[adjC.length - 3];
                                } else {
                                    if (adjC.length >= 1) prevClose     = adjC[adjC.length - 1];
                                    if (adjC.length >= 2) prevPrevClose = adjC[adjC.length - 2];
                                }
                            } catch(_) {}
                        }

                        return {
                            pe, fpe, peg, ps,
                            pb:              f.pb              ?? null,
                            rev_yoy:         f.rev_yoy         ?? null,
                            rev_fwd:         f.rev_fwd         ?? null,
                            hist_avg_pe:     f.hist_avg_pe     ?? null,
                            gross_margin:    f.gross_margin    ?? null,
                            operating_margin:f.operating_margin?? null,
                            eps_ttm, eps_cur_q, eps_next_q, eps_cur_y, eps_next_y,
                            prevClose, prevPrevClose, marketOpenedToday,
                            daily_k:  f.daily_k  ?? null, daily_d:  f.daily_d  ?? null, daily_cross:  f.daily_cross  ?? 'none',
                            weekly_k: f.weekly_k ?? null, weekly_d: f.weekly_d ?? null, weekly_cross: f.weekly_cross ?? 'none',
                            hourly_k: f.hourly_k ?? null, hourly_d: f.hourly_d ?? null, hourly_cross: f.hourly_cross ?? 'none',
                            daily_macd:  f.daily_macd  ?? null,
                            weekly_macd: f.weekly_macd ?? null,
                            hourly_macd: f.hourly_macd ?? null,
                            daily_rsi:   f.daily_rsi   ?? null,
                            weekly_rsi:  f.weekly_rsi  ?? null,
                            hourly_rsi:  f.hourly_rsi  ?? null,
                            next_earnings_date,
                            no_earnings,
                            earnings_proxy_symbol,
                        };
                    }
                    // （此路徑不再到達）繼續往下抓技術面
                }
            } catch(_) {}

            // ══════════════════════════════════════════════════════════════════
            // ①.5 查 GitHub 全域快取（data/cache.json）跨裝置共享，2小時 TTL
            // ══════════════════════════════════════════════════════════════════
            if (pe === null) {
                try {
                    const gc = await _loadGlobalCache();
                    const cf = gc?.fundamentals?.[symbol];
                    if (cf && !cf.error && (Date.now() - (cf.fetched_at || 0)) < FUND_CACHE_TTL) {
                        fund       = cf;
                        pe         = cf.pe         ?? null;
                        fpe        = cf.fpe        ?? null;
                        peg        = cf.peg        ?? null;
                        ps         = cf.ps         ?? null;
                        eps_ttm    = cf.eps_ttm    ?? null;
                        eps_cur_q  = cf.eps_cur_q  ?? null;
                        eps_next_q = cf.eps_next_q ?? null;
                        eps_cur_y  = cf.eps_cur_y  ?? null;
                        eps_next_y = cf.eps_next_y ?? null;
                    }
                } catch(_) {}
            }

            // ══════════════════════════════════════════════════════════════════
            // ② 有後端時呼叫 /yfundamentals 即時抓取
            // ══════════════════════════════════════════════════════════════════
            if (pe === null && (fundBase !== '' || _isLocal)) {
                try {
                    const fundResp = await fetch((fundBase || '') + '/yfundamentals?symbol=' + encodeURIComponent(symbol));
                    if (fundResp.ok) {
                        const raw = await fundResp.json();
                        if (!raw.error) {
                            fund       = raw;
                            pe         = raw.pe         ?? null;
                            fpe        = raw.fpe        ?? null;
                            peg        = raw.peg        ?? null;
                            ps         = raw.ps         ?? null;
                            eps_ttm    = raw.eps_ttm    ?? null;
                            eps_cur_q  = raw.eps_cur_q  ?? null;
                            eps_next_q = raw.eps_next_q ?? null;
                            eps_cur_y  = raw.eps_cur_y  ?? null;
                            eps_next_y = raw.eps_next_y ?? null;
                            // 成功抓取 → 回寫全域快取（非同步，不阻塞）
                            try {
                                const gc = await _loadGlobalCache();
                                gc.fundamentals[symbol] = { ...raw, fetched_at: Date.now() };
                                _globalCacheDirty = true;
                                _pushGlobalCache();
                            } catch(_) {}
                        }
                    }
                } catch(_) {}
            }
            // ③ 並行抓取三個週期 K 線圖
            // 週線加入 events=earnings → 免認證取得各季 EPS Actual/Estimate
            // Yahoo Finance v6/v7/v10 quote API 均需 crumb 認證，已全面停用。
            const [weeklyData, dailyData, hourlyData] = await Promise.all([
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1wk&range=2y&events=earnings`).catch(() => null),
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1d&range=3mo`).catch(() => null),
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1h&range=5d`).catch(() => null)
            ]);

            // 從週線 earnings events 計算 TTM EPS 及本益比（完全免認證）
            if (pe === null) {
                const eventsMap = weeklyData?.chart?.result?.[0]?.events?.earnings ?? {};
                const sortedEps = Object.entries(eventsMap)
                    .sort(([a], [b]) => Number(a) - Number(b))
                    .map(([, e]) => e.epsActual ?? e.actual ?? null)
                    .filter(v => v != null);
                if (sortedEps.length >= 1) {
                    eps_ttm = parseFloat(sortedEps.slice(-4).reduce((a, b) => a + b, 0).toFixed(4));
                    fund = { ...fund, eps_ttm };
                    const mktPrice = weeklyData?.chart?.result?.[0]?.meta?.regularMarketPrice;
                    if (mktPrice != null && eps_ttm > 0) {
                        pe = parseFloat((mktPrice / eps_ttm).toFixed(2));
                    }
                    console.log(`[基本面] ${symbol} EPS_TTM=${eps_ttm} PE=${pe}`);
                }
            }

            const weeklyQ = weeklyData?.chart?.result?.[0]?.indicators?.quote?.[0] ?? {};
            const dailyQ  = dailyData?.chart?.result?.[0]?.indicators?.quote?.[0]  ?? {};
            const hourlyQ = hourlyData?.chart?.result?.[0]?.indicators?.quote?.[0] ?? {};

            const weeklyKD = calcKD(weeklyQ.high, weeklyQ.low, weeklyQ.close);
            const dailyKD  = calcKD(dailyQ.high,  dailyQ.low,  dailyQ.close);
            const hourlyKD = calcKD(hourlyQ.high, hourlyQ.low, hourlyQ.close);

            const kdCross = kd => kd ? (kd.crossUp ? 'golden' : kd.crossDown ? 'death' : 'none') : 'none';

            const weeklyC    = weeklyQ.close, dailyC = dailyQ.close, hourlyC = hourlyQ.close;
            const weeklyMACD = calcMACD(weeklyC);
            const dailyMACD  = calcMACD(dailyC);
            const hourlyMACD = calcMACD(hourlyC);
            const weeklyRSI  = calcRSI(weeklyC);
            const dailyRSI   = calcRSI(dailyC);
            const hourlyRSI  = calcRSI(hourlyC);

            // 昨收價 & 前日收盤：判斷今日是否開盤後，選正確 index
            let prevClose     = fund?.prev_close      ?? null;
            let prevPrevClose = fund?.prev_prev_close ?? null;
            const dailyTs3   = dailyData?.chart?.result?.[0]?.timestamp ?? [];
            const lastDailyTs = dailyTs3[dailyTs3.length - 1];
            const _tz3 = _exchangeTz(symbol);
            const todayET3    = new Date().toLocaleDateString('en-US', {timeZone:_tz3});
            const barET3      = lastDailyTs ? new Date(lastDailyTs*1000).toLocaleDateString('en-US',{timeZone:_tz3}) : '';
            const marketOpenedToday = (todayET3 === barET3);
            const valid3 = Array.isArray(dailyC) ? dailyC.filter(c => c != null) : [];
            if (marketOpenedToday) {
                // 最後一根 = 今日進行中 → [-2]=昨日, [-3]=前日
                if (prevClose == null && valid3.length >= 2)     prevClose     = valid3[valid3.length - 2];
                if (prevPrevClose == null && valid3.length >= 3) prevPrevClose = valid3[valid3.length - 3];
            } else {
                // 最後一根 = 昨日（今日未開盤）→ [-1]=昨日, [-2]=前日
                if (prevClose == null && valid3.length >= 1)     prevClose     = valid3[valid3.length - 1];
                if (prevPrevClose == null && valid3.length >= 2) prevPrevClose = valid3[valid3.length - 2];
            }

            return {
                pe, fpe, peg, ps,
                pb:              fund?.pb              ?? null,
                rev_yoy:         fund?.rev_yoy         ?? null,
                rev_fwd:         fund?.rev_fwd         ?? null,
                hist_avg_pe:     fund?.hist_avg_pe     ?? null,
                gross_margin:    fund?.gross_margin    ?? null,
                operating_margin:fund?.operating_margin?? null,
                eps_ttm, eps_cur_q, eps_next_q, eps_cur_y, eps_next_y,
                prevClose, prevPrevClose, marketOpenedToday,
                weekly_k: weeklyKD?.k ?? null, weekly_d: weeklyKD?.d ?? null, weekly_cross: kdCross(weeklyKD),
                daily_k:  dailyKD?.k  ?? null, daily_d:  dailyKD?.d  ?? null, daily_cross:  kdCross(dailyKD),
                hourly_k: hourlyKD?.k ?? null, hourly_d: hourlyKD?.d ?? null, hourly_cross: kdCross(hourlyKD),
                weekly_macd: weeklyMACD, daily_macd: dailyMACD, hourly_macd: hourlyMACD,
                weekly_rsi:  weeklyRSI,  daily_rsi:  dailyRSI,  hourly_rsi:  hourlyRSI,
                next_earnings_date:    fund?.next_earnings_date    ?? null,
                no_earnings:           fund?.no_earnings           === true,
                earnings_proxy_symbol: fund?.earnings_proxy_symbol ?? null
            };
        }


        // ==================== 技術面專用抓取（供1小時背景刷新使用）====================
        async function fetchTechDataFromYahoo(symbol) {
            const BASE1 = 'https://query1.finance.yahoo.com';
            const [weeklyData, dailyData, hourlyData] = await Promise.all([
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1wk&range=2y&events=earnings`).catch(() => null),
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1d&range=3mo`).catch(() => null),
                yfFetch(`${BASE1}/v8/finance/chart/${encodeURIComponent(symbol)}?interval=1h&range=5d`).catch(() => null)
            ]);
            const weeklyQ = weeklyData?.chart?.result?.[0]?.indicators?.quote?.[0] ?? {};
            const dailyQ  = dailyData?.chart?.result?.[0]?.indicators?.quote?.[0]  ?? {};
            const hourlyQ = hourlyData?.chart?.result?.[0]?.indicators?.quote?.[0] ?? {};
            const weeklyKD = calcKD(weeklyQ.high, weeklyQ.low, weeklyQ.close);
            const dailyKD  = calcKD(dailyQ.high,  dailyQ.low,  dailyQ.close);
            const hourlyKD = calcKD(hourlyQ.high, hourlyQ.low, hourlyQ.close);
            const kdCross  = kd => kd ? (kd.crossUp ? 'golden' : kd.crossDown ? 'death' : 'none') : 'none';
            const weeklyC  = weeklyQ.close, dailyC = dailyQ.close, hourlyC = hourlyQ.close;
            // prevClose & marketOpenedToday
            // 用 _exchangeTz() 依標的市場選擇正確時區判斷今日是否開盤
            const dailyTs  = dailyData?.chart?.result?.[0]?.timestamp ?? [];
            const lastTs   = dailyTs[dailyTs.length - 1];
            const _tz      = _exchangeTz(symbol);
            const todayET  = new Date().toLocaleDateString('en-US', {timeZone: _tz});
            const barET    = lastTs ? new Date(lastTs*1000).toLocaleDateString('en-US', {timeZone: _tz}) : '';
            const opened   = (todayET === barET);
            const valid    = Array.isArray(dailyC) ? dailyC.filter(c => c != null) : [];
            const adjC     = valid.slice();
            if (!opened) { while (adjC.length >= 2 && adjC[adjC.length-1] === adjC[adjC.length-2]) adjC.pop(); }
            let prevClose = null, prevPrevClose = null;
            if (opened) {
                if (adjC.length >= 2) prevClose     = adjC[adjC.length - 2];
                if (adjC.length >= 3) prevPrevClose = adjC[adjC.length - 3];
            } else {
                if (adjC.length >= 1) prevClose     = adjC[adjC.length - 1];
                if (adjC.length >= 2) prevPrevClose = adjC[adjC.length - 2];
            }
            return {
                weekly_k: weeklyKD?.k ?? null, weekly_d: weeklyKD?.d ?? null, weekly_cross: kdCross(weeklyKD),
                daily_k:  dailyKD?.k  ?? null, daily_d:  dailyKD?.d  ?? null, daily_cross:  kdCross(dailyKD),
                hourly_k: hourlyKD?.k ?? null, hourly_d: hourlyKD?.d ?? null, hourly_cross: kdCross(hourlyKD),
                weekly_macd: calcMACD(weeklyC), daily_macd: calcMACD(dailyC), hourly_macd: calcMACD(hourlyC),
                weekly_rsi:  calcRSI(weeklyC),  daily_rsi:  calcRSI(dailyC),  hourly_rsi:  calcRSI(hourlyC),
                prevClose, prevPrevClose, marketOpenedToday: opened
            };
        }

        // ==================== 後端網址設定 ====================
        // #endregion Analysis Data
        async function runDiagnostics() {
            const results = [];
            const log = (msg, ok) => results.push((ok ? '✅' : '❌') + ' ' + msg);

            // 測試 1：fundamentals.json
            try {
                const t0 = Date.now();
                const r = await fetch('./data/fundamentals.json', { cache: 'no-store' });
                const ms = Date.now() - t0;
                if (r.ok) {
                    const txt = await r.text();
                    const cleaned = txt.replace(/:\s*NaN/g, ': null').replace(/:\s*Infinity/g, ': null').replace(/:\s*-Infinity/g, ': null');
                    const d = JSON.parse(cleaned);
                    const count = Object.keys(d.data || {}).length;
                    const hasNaN = txt.includes(':NaN') || txt.includes(': NaN');
                    log(`fundamentals.json (${ms}ms, ${count} 筆)${hasNaN ? ' ⚠️含NaN(已清理)' : ''}`, true);
                } else {
                    log(`fundamentals.json HTTP ${r.status}`, false);
                }
            } catch(e) { log(`fundamentals.json 失敗: ${e.message}`, false); }

            // 測試 2：CORS Proxy (corsproxy.io)
            const testUrl = 'https://query1.finance.yahoo.com/v8/finance/chart/AAPL?interval=1d&range=1d';
            const proxies = [
                ['corsproxy.io', 'https://corsproxy.io/?' + encodeURIComponent(testUrl)],
                ['codetabs.com', 'https://api.codetabs.com/v1/proxy?quest=' + encodeURIComponent(testUrl)],
            ];
            for (const [name, url] of proxies) {
                try {
                    const t0 = Date.now();
                    const r = await fetch(url, { signal: AbortSignal.timeout(8000) });
                    const ms = Date.now() - t0;
                    log(`Proxy ${name} (${ms}ms) HTTP ${r.status}`, r.ok);
                } catch(e) { log(`Proxy ${name} 失敗: ${e.message}`, false); }
            }

            // 測試 3：localStorage 空間
            try {
                const used = JSON.stringify(localStorage).length;
                log(`localStorage 已用 ${(used/1024).toFixed(1)} KB`, true);
            } catch(e) { log(`localStorage 錯誤: ${e.message}`, false); }

            // 測試 4：backend_url + Render 連線
            const bu = localStorage.getItem('backend_url');
            log(`backend_url: ${bu || '（未設定）'}`, !!bu);
            if (bu) {
                try {
                    const t0 = Date.now();
                    const r = await fetch(bu + '/yfundamentals?symbol=NVDA', { signal: AbortSignal.timeout(15000) });
                    const ms = Date.now() - t0;
                    const d = await r.json();
                    log(`Render /yfundamentals (${ms}ms) PE=${d.pe ?? 'null'}`, r.ok && !d.error);
                } catch(e) { log(`Render /yfundamentals 失敗: ${e.message}`, false); }
            }

            // 顯示結果
            alert('=== 連線診斷結果 ===\n\n' + results.join('\n'));
        }

        async function forceUpdatePWA() {
            if (!confirm('清除所有 Service Worker 快取並重新載入頁面？')) return;
            try {
                const keys = await caches.keys();
                await Promise.all(keys.map(k => caches.delete(k)));
                const regs = await navigator.serviceWorker.getRegistrations();
                await Promise.all(regs.map(r => r.unregister()));
            } catch(e) {}
            window.location.reload(true);
        }

        function setBackendUrl() {
            const current = localStorage.getItem('backend_url') || '';
            const url = window.prompt(
                '請輸入 Render.com 後端網址\n（本機開發請留空）\n\n範例：https://portfolio-tracker-api.onrender.com',
                current
            );
            if (url === null) return;
            const trimmed = url.trim().replace(/\/$/, '');
            if (trimmed === '') {
                localStorage.removeItem('backend_url');
                document.getElementById('fund-source-time').textContent = '（本機模式）';
            } else {
                localStorage.setItem('backend_url', trimmed);
                document.getElementById('fund-source-time').textContent = '✓ 後端已設定';
            }
            location.reload();
        }

        // 頁面載入時顯示基本面 & 技術面各自的最後更新時間
        const _fmtTs = ts => new Date(ts).toLocaleString('zh-TW', {
            timeZone:'Asia/Taipei', month:'2-digit', day:'2-digit', hour:'2-digit', minute:'2-digit'
        });
        function _updateSourceTimes(fundTs, techTs) {
            const fundEl = document.getElementById('fund-source-time');
            const techEl = document.getElementById('tech-source-time');
            const now = Date.now();
            // v15.063：依資料年齡套色（基本面 TTL 8hr：<6hr 新鮮、6-12hr 接近過期、>12hr 已過期）
            if (fundEl && fundTs) {
                const age = now - new Date(fundTs).getTime();
                fundEl.textContent = '基本面：' + _fmtTs(fundTs) + ' 更新';
                fundEl.style.color = _freshnessColor(age, 6*60*60*1000, 12*60*60*1000);
            }
            // 技術面 TTL 1hr：<45min 新鮮、45-90min 接近過期、>90min 已過期
            if (techEl && techTs) {
                const age = now - new Date(techTs).getTime();
                techEl.textContent = '｜ 技術面：' + _fmtTs(techTs) + ' 更新';
                techEl.style.color = _freshnessColor(age, 45*60*1000, 90*60*1000);
            }
        }
        (function() {
            // 基本面：讀 fundamentals.json 的 generated 時間
            fetch('./data/fundamentals.json')
                .then(r => r.ok ? r.json() : null)
                .then(j => {
                    if (j?.generated) _updateSourceTimes(j.generated, null);
                })
                .catch(() => {});
            // 技術面：讀 localStorage 的 tech_ts
            try {
                const raw = JSON.parse(localStorage.getItem('pf_analysis_v8') || '{}');
                if (raw.tech_ts) _updateSourceTimes(null, raw.tech_ts);
            } catch(_) {}
        })();

        // ==================== Analysis Cache (localStorage, 基本面4hr / 技術面1hr TTL) ====================
        const _CACHE_KEY = 'pf_analysis_v8';   // v8：加入 next_earnings_date / no_earnings / earnings_proxy_symbol 後強制清除舊快取
        const _FUND_TTL  = 8 * 60 * 60 * 1000; // 基本面：8 小時（原 4hr，延長減少 proxy 失敗機率）
        const _TECH_TTL  = 1 * 60 * 60 * 1000; // 技術面：1 小時
        function _loadCacheRaw() {
            try { return JSON.parse(localStorage.getItem(_CACHE_KEY)||'{}'); } catch { return {}; }
        }
        function _loadCache() {
            // 供「基本面過期」路徑：fund TTL 未到期才返回快取資料
            const r = _loadCacheRaw();
            return (Date.now() - (r.fund_ts||0) < _FUND_TTL) ? (r.data||{}) : {};
        }
        function _isFundFresh() { const r = _loadCacheRaw(); return (Date.now() - (r.fund_ts||0) < _FUND_TTL); }
        function _isTechFresh() { const r = _loadCacheRaw(); return (Date.now() - (r.tech_ts||0) < _TECH_TTL); }
        function _saveCache(data) {
            // 完整抓取後呼叫，同時更新基本面 & 技術面時間戳
            const now = Date.now();
            try { localStorage.setItem(_CACHE_KEY, JSON.stringify({fund_ts:now, tech_ts:now, data})); } catch {}
        }
        function _saveTechCache(data) {
            // 技術面專用刷新後呼叫，僅更新 tech_ts（保留 fund_ts 不變）
            const r = _loadCacheRaw();
            try { localStorage.setItem(_CACHE_KEY, JSON.stringify({...r, tech_ts:Date.now(), data})); } catch {}
        }

        // ==================== Main Analysis Loader ====================
        async function loadAnalysis(forceRefresh, silent = false) {
            if (holdings.length === 0) { if (!silent) alert('請先匯入持倉數據'); return; }

            const btn = document.getElementById('analysis-btn');
            btn.textContent = '載入中...'; btn.disabled = true;

            // 使用本地暫存快取，分析完成前保留舊值讓自動更新仍可顯示損益
            // （只有在所有資料抓取完畢後才一次性替換全域快取）
            const _tmpPrevClose     = {};
            const _tmpPrevPrevClose = {};
            const _tmpMarketOpened  = {};

            // 無後端時清除 _fundJsonCache，確保每次「強制重整」都重新讀取 fundamentals.json
            if (forceRefresh) window._fundJsonCache = null;
            const fundNote = document.getElementById('fund-backend-note');
            if (fundNote) fundNote.style.display = 'none';

            const fundTbody = document.getElementById('fund-tbody');
            const techTbody = document.getElementById('tech-tbody');

            const rows = _allAnalysisTargets().map(h => ({
                holding:      h.symbol,
                query:        getQuerySymbol(h.symbol),
                isProxy:      !!LEVERAGED_MAP[h.symbol],
                isWatchlist:  !!h._isWatchlist
            }));

            // 共用 loading 渲染函數（隱藏查詢標的欄）
            const loadingRow = (r, colspan, msg) =>
                '<tr id="arow-' + r.holding.replace(/[^a-zA-Z0-9]/g,'_') + '" style="border-bottom:1px solid rgba(255,255,255,0.05);">' +
                '<td style="padding:0.5rem 0.6rem; font-weight:700; color:#f1f5f9;">' + r.holding +
                    (r.isProxy ? '<br><small style="color:#3b82f6;font-size:0.72rem;">' + r.query + ' (原型)</small>' : '') +
                    (r.isWatchlist ? '<br><small style="color:#7e93a6;font-size:0.7rem;background:rgba(56,139,253,0.08);padding:0.05rem 0.3rem;border-radius:3px;">觀察中</small>' : '') + '</td>' +
                '<td colspan="' + colspan + '" style="text-align:center; color:#7e93a6; font-size:0.82rem; padding:0.5rem;">' + msg + '</td></tr>';

            // ── 判斷快取狀態（基本面4hr / 技術面1hr）──
            const fundFresh = !forceRefresh && _isFundFresh();
            const techFresh = !forceRefresh && _isTechFresh();
            const uniqueQueries = [...new Set(rows.map(r => r.query))];

            // 初始資料：從原始快取（localStorage）取，無論哪條路徑都先有基礎值
            let allResults = { ...(_loadCacheRaw().data || {}) };

            if (fundFresh && techFresh) {
                // ── 快取完全有效 → 直接渲染，不發任何 API 請求 ──
                // （直接 fall through 到 Render 區塊）

            } else if (fundFresh && !techFresh) {
                // ── 技術面過期 → 只重抓 KD/MACD/RSI + prevClose ──
                // 基本面資料仍有效，不清空 fundTbody，只更新技術面 loading 狀態
                if (!silent) {
                    techTbody.innerHTML = rows.map(r => loadingRow(r, 10, '⏳ 更新技術面...')).join('').replace(/arow-/g, 'trow-');
                }
                for (let i = 0; i < uniqueQueries.length; i++) {
                    const sym = uniqueQueries[i];
                    if (!silent) {
                        const prog = '⏳ 更新技術面（' + (i+1) + '/' + uniqueQueries.length + '）...';
                        rows.filter(r => r.query === sym).forEach(r => {
                            const te = document.getElementById('trow-' + r.holding.replace(/[^a-zA-Z0-9]/g,'_'));
                            if (te) { te.cells[1].colSpan = 10; te.cells[1].textContent = prog; }
                        });
                    }
                    try {
                        const tech = await fetchTechDataFromYahoo(sym);
                        allResults[sym] = { ...(allResults[sym] || {}), ...tech };
                    } catch(_) {}
                    if (i < uniqueQueries.length - 1) await new Promise(res => setTimeout(res, 200));
                }
                // 槓桿 ETF：用自身日線取技術面 & prevClose
                const proxyRowsT = rows.filter(r => r.isProxy);
                for (let pi = 0; pi < proxyRowsT.length; pi++) {
                    const _psym = proxyRowsT[pi].holding;
                    try {
                        const tech = await fetchTechDataFromYahoo(_psym);
                        allResults[_psym] = { ...(allResults[_psym] || {}), ...tech };
                    } catch(_) {}
                    // range=5d 偵測今日是否開盤；開盤時再用 range=1d chartPreviousClose 取昨收
                    // （range=1d chartPreviousClose 可跨越空白交易日，比 close array 更可靠）
                    try {
                        const _BASE_pc = 'https://query1.finance.yahoo.com';
                        const _pd5 = await yfFetch(`${_BASE_pc}/v8/finance/chart/${encodeURIComponent(_psym)}?interval=1d&range=5d`);
                        const _pr5 = _pd5?.chart?.result?.[0];
                        const _pts = _pr5?.timestamp ?? [];
                        const _praw = _pr5?.indicators?.quote?.[0]?.close ?? [];
                        const _pccy = _pr5?.meta?.currency ?? '';
                        const _pscale = (HK_USD_PRICED.has(_psym) && _pccy === 'HKD')
                            ? (exchangeRates.HKD_TWD / exchangeRates.USD_TWD) : 1;
                        const _pcls = _praw.filter(c => c != null).map(c => c * _pscale);
                        const _plast = _pts[_pts.length - 1];
                        const _ptz = _exchangeTz(_psym);
                        const _ptd = new Date().toLocaleDateString('en-US', {timeZone: _ptz});
                        const _pbd = _plast ? new Date(_plast * 1000).toLocaleDateString('en-US', {timeZone: _ptz}) : '';
                        const _popened = (_ptd === _pbd);
                        if (!allResults[_psym]) allResults[_psym] = {};
                        allResults[_psym].marketOpenedToday = _popened;
                        if (_popened) {
                            // 今日開盤：range=1d chartPreviousClose 取昨收（跨越空白交易日仍準確）
                            let _cpc = null;
                            try {
                                const _pd1 = await yfFetch(`${_BASE_pc}/v8/finance/chart/${encodeURIComponent(_psym)}?interval=1d&range=1d`);
                                const _m1  = _pd1?.chart?.result?.[0]?.meta;
                                const _sc1 = (HK_USD_PRICED.has(_psym) && (_m1?.currency ?? '') === 'HKD')
                                    ? (exchangeRates.HKD_TWD / exchangeRates.USD_TWD) : 1;
                                if (_m1?.chartPreviousClose != null) _cpc = _m1.chartPreviousClose * _sc1;
                            } catch(_) {}
                            allResults[_psym].prevClose     = _cpc ?? (_pcls.length >= 2 ? _pcls[_pcls.length - 2] : null);
                            if (_pcls.length >= 3) allResults[_psym].prevPrevClose = _pcls[_pcls.length - 3];
                        } else {
                            const _padj = _pcls.slice();
                            while (_padj.length >= 2 && _padj[_padj.length-1] === _padj[_padj.length-2]) _padj.pop();
                            if (_padj.length >= 1) allResults[_psym].prevClose     = _padj[_padj.length - 1];
                            if (_padj.length >= 2) allResults[_psym].prevPrevClose = _padj[_padj.length - 2];
                        }
                    } catch(_) {}
                    if (pi < proxyRowsT.length - 1) await new Promise(res => setTimeout(res, 200));
                }
                _saveTechCache(allResults);

            } else {
                // ── 基本面（或全部）過期 → 完整重抓 ──
                fundTbody.innerHTML = rows.map(r => loadingRow(r, 15, '⏳ 查詢中...')).join('');
                techTbody.innerHTML = rows.map(r => loadingRow(r, 10, '⏳ 查詢中...')).join('').replace(/arow-/g, 'trow-');

                // 過期時先用舊資料初始化（stale fallback），重抓成功才覆蓋
                const staleData = _loadCacheRaw().data || {};
                const freshCache = forceRefresh ? {} : _loadCache();
                allResults = { ...staleData, ...freshCache };
                const toFetch = forceRefresh
                    ? uniqueQueries
                    : uniqueQueries.filter(s => !freshCache[s]);

                let fetchSuccessCount = 0;
                for (let i = 0; i < toFetch.length; i++) {
                    const sym = toFetch[i];
                    const prog = '⏳ 查詢中（' + (i+1) + '/' + toFetch.length + '）...';
                    rows.filter(r => r.query === sym).forEach(r => {
                        const fe = document.getElementById('arow-' + r.holding.replace(/[^a-zA-Z0-9]/g,'_'));
                        const te = document.getElementById('trow-' + r.holding.replace(/[^a-zA-Z0-9]/g,'_'));
                        if (fe) { fe.cells[1].colSpan = 15; fe.cells[1].textContent = prog; }
                        if (te) { te.cells[1].colSpan = 10; te.cells[1].textContent = prog; }
                    });
                    try {
                        allResults[sym] = await fetchSymbolDataFromYahoo(sym);
                        fetchSuccessCount++;
                    } catch(e) {
                        // 失敗時保留 staleData（不覆蓋），只記 log
                        if (!staleData[sym]) allResults[sym] = { _error: e.message };
                        console.warn(`[分析] ${sym} 抓取失敗，保留舊快取：`, e.message);
                    }
                    if (i < toFetch.length - 1) await new Promise(res => setTimeout(res, 200));
                }
                // 至少有一筆成功才更新時間戳；全部失敗時只渲染舊資料，不動 localStorage
                if (fetchSuccessCount > 0) _saveCache(allResults);

                // ── 偵測未在 fundamentals.json 中的新標的（GitHub Pages 模式）──
                if (!_isLocal && !BACKEND_URL && window._fundJsonCache?.data) {
                    const fundData = window._fundJsonCache.data;
                    const missing = uniqueQueries.filter(s => !fundData[s] && s !== 'BTC-USD');
                    if (missing.length > 0) _showMissingFundNotice(missing);
                }
            }

            // ── 毛利率/營益率：v8/chart events 不含此資訊；quoteSummary 需 crumb 已停用 ──

            // ── Render ──（全量重建表格，支援快取直接命中時表格為空的情況）
            const fmt  = v => (v != null && !isNaN(v)) ? parseFloat(v).toFixed(2) : '-';
            const fmtp = v => (v != null && !isNaN(v)) ? (parseFloat(v)*100).toFixed(1) + '%' : '-';
            const tr   = (v, a) => '<td style="padding:0.5rem 0.6rem; text-align:' + (a||'right') + '; color:#e2e8f0;">' + v + '</td>';
            const trc  = v => '<td style="padding:0.5rem 0.6rem; text-align:center;">' + v + '</td>';
            const buildNextEarningsTd = (dateStr, noEarnings, proxySymbol) => {
                if (noEarnings === true) {
                    return '<td style="padding:0.5rem 0.6rem; text-align:center; color:#7e93a6; font-size:0.82rem;">近期無財報</td>';
                }
                if (!dateStr || typeof dateStr !== 'string' || dateStr.length < 10) {
                    return '<td style="padding:0.5rem 0.6rem; text-align:center; color:#607585;">-</td>';
                }
                // 以「本地日期 00:00」為基準計算剩餘天數，避免時區漂移
                const today = new Date(); today.setHours(0,0,0,0);
                const [y,m,dd] = dateStr.substring(0,10).split('-').map(n => parseInt(n, 10));
                const target = new Date(y, (m||1)-1, dd||1);
                const days = Math.round((target - today) / 86400000);
                let color, label;
                if (days < 0)        { color = '#607585'; label = `${Math.abs(days)} 天前`; }
                else if (days === 0) { color = '#ef4444'; label = '今日'; }
                else if (days <= 7)  { color = '#ef4444'; label = `剩 ${days} 天`; }
                else if (days <= 14) { color = '#fbbf24'; label = `剩 ${days} 天`; }
                else if (days <= 30) { color = '#e2e8f0'; label = `剩 ${days} 天`; }
                else                 { color = '#607585'; label = `剩 ${days} 天`; }
                const proxyHint = proxySymbol ? `<div style="color:#7e93a6; font-size:0.7rem; margin-top:0.05rem;">財報：${proxySymbol}</div>` : '';
                return `<td style="padding:0.5rem 0.6rem; text-align:center; line-height:1.35;"><div style="color:#e2e8f0; font-weight:600;">${dateStr}</div><div style="color:${color}; font-size:0.76rem; margin-top:0.1rem;">${label}</div>${proxyHint}</td>`;
            };
            const buildKD = (k, dv, cross) => {
                if (k == null) return '<span class="kd-neu">-</span>';
                const up = cross==='golden', dn = cross==='death';
                const lbl = up ? '▲ 黃金交叉' : dn ? '▼ 死亡交叉' : (parseFloat(k)>parseFloat(dv) ? 'K>D' : 'K<D');
                return '<span class="'+(up?'kd-up':dn?'kd-down':'kd-neu')+'">'+ lbl +'</span><br><small style="color:#7e93a6;font-size:0.75rem;">K:'+parseFloat(k).toFixed(1)+' D:'+parseFloat(dv).toFixed(1)+'</small>';
            };
            const fundRowsHtml = [], techRowsHtml = [];
            rows.forEach(r => {
                const rowId  = r.holding.replace(/[^a-zA-Z0-9]/g,'_');
                const d      = allResults[r.query];
                const symTd  = '<td style="padding:0.5rem 0.6rem; font-weight:700; color:#f1f5f9;">' + r.holding +
                    (r.isProxy ? '<br><small style="color:#3b82f6;font-size:0.72rem;">' + r.query + ' (原型)</small>' : '') +
                    (r.isWatchlist ? '<br><small style="color:#7e93a6;font-size:0.7rem;background:rgba(56,139,253,0.08);padding:0.05rem 0.3rem;border-radius:3px;">觀察中</small>' : '') + '</td>';
                const rowStyle = `data-symbol="${r.holding}" style="border-bottom:1px solid rgba(255,255,255,0.05);"`;


                if (d?._pending) {
                    const msg = '⏳ 資料同步中，待下次 Actions 更新';
                    fundRowsHtml.push(`<tr id="arow-${rowId}" ${rowStyle}>${symTd}<td colspan="16" style="color:#7e93a6;font-size:0.82rem;padding:0.5rem;">${msg}</td></tr>`);
                    techRowsHtml.push(`<tr id="trow-${rowId}" ${rowStyle}>${symTd}<td colspan="10" style="color:#7e93a6;font-size:0.82rem;padding:0.5rem;">${msg}</td></tr>`);
                    return;
                }
                if (!d || d._error) {
                    const errMsg = '❌ ' + (d?._error||'無數據').split('\n')[0];
                    fundRowsHtml.push(`<tr id="arow-${rowId}" ${rowStyle}>${symTd}<td colspan="16" style="color:#ef4444;font-size:0.82rem;padding:0.5rem;">${errMsg}</td></tr>`);
                    techRowsHtml.push(`<tr id="trow-${rowId}" ${rowStyle}>${symTd}<td colspan="10" style="color:#ef4444;font-size:0.82rem;padding:0.5rem;">${errMsg}</td></tr>`);
                    return;
                }

                // 基本面行
                fundRowsHtml.push(`<tr id="arow-${rowId}" ${rowStyle}>${symTd}` +
                    buildNextEarningsTd(d.next_earnings_date, d.no_earnings, d.earnings_proxy_symbol) +
                    tr(fmt(d.pe)) + tr(fmt(d.hist_avg_pe)) + tr(fmt(d.fpe)) +
                    tr(fmt(d.peg)) + tr(fmt(d.ps)) + tr(fmt(d.pb)) +
                    tr(fmtp(d.rev_yoy)) + tr(fmtp(d.rev_fwd)) +
                    tr(fmtp(d.gross_margin)) + tr(fmtp(d.operating_margin)) +
                    tr(fmt(d.eps_cur_q)) + tr(fmt(d.eps_next_q)) + tr(fmt(d.eps_ttm)) + tr(fmt(d.eps_cur_y)) + tr(fmt(d.eps_next_y)) + '</tr>');

                // 技術面行
                techRowsHtml.push(`<tr id="trow-${rowId}" ${rowStyle}>${symTd}` +
                    trc(buildKD(d.hourly_k, d.hourly_d, d.hourly_cross)) +
                    trc(buildKD(d.daily_k,  d.daily_d,  d.daily_cross))  +
                    trc(buildKD(d.weekly_k, d.weekly_d, d.weekly_cross)) +
                    trc(macdBadge(d.hourly_macd)) + trc(macdBadge(d.daily_macd)) + trc(macdBadge(d.weekly_macd)) +
                    trc(rsiBadge(d.hourly_rsi))   + trc(rsiBadge(d.daily_rsi))   + trc(rsiBadge(d.weekly_rsi)) +
                    '<td style="padding:0.5rem 0.6rem; text-align:center; background:rgba(56,139,253,0.04);">' + techSummaryBadge(d) + '</td></tr>');
            });
            fundTbody.innerHTML = fundRowsHtml.join('');
            techTbody.innerHTML = techRowsHtml.join('');
            _applyAnalysisRowSelection();

            btn.textContent = '↻ 更新分析數據'; btn.disabled = false;

            // ── 儲存 prevClose / prevPrevClose / marketOpenedToday 至本地暫存 ──
            // 代理/槓桿 ETF 用自己的 key（r.holding），普通股用 r.query
            rows.forEach(r => {
                const d = r.isProxy ? allResults[r.holding] : allResults[r.query];
                if (d) {
                    if (d.prevClose         != null) _tmpPrevClose[r.holding]     = d.prevClose;
                    if (d.prevPrevClose     != null) _tmpPrevPrevClose[r.holding] = d.prevPrevClose;
                    if (d.marketOpenedToday != null) _tmpMarketOpened[r.holding]  = d.marketOpenedToday;
                }
            });

            // ── 補抓 prevClose（只在有資料更新時執行，快取完全有效時跳過）──
            if (!fundFresh || !techFresh) {
                // 非代理股：補抓 prevClose 遺漏的情況
                {
                    const BASE1_pc = 'https://query1.finance.yahoo.com';
                    const missingSyms = [...new Set(
                        rows.filter(r => !r.isProxy && (
                            _tmpPrevClose[r.holding] == null ||
                            _tmpPrevPrevClose[r.holding] == null ||
                            _tmpPrevClose[r.holding] === _tmpPrevPrevClose[r.holding]
                        )).map(r => ({ holding: r.holding, query: r.query }))
                            .filter((v, i, a) => a.findIndex(x => x.holding === v.holding) === i)
                    )];
                    for (let mi = 0; mi < missingSyms.length; mi++) {
                        const { holding, query } = missingSyms[mi];
                        try {
                            const qd = await yfFetch(`${BASE1_pc}/v8/finance/chart/${holding}?interval=1d&range=5d`);
                            const ch = qd?.chart?.result?.[0];
                            const tss = ch?.timestamp ?? [];
                            // v15.080 後續修補：zip + filter 對齊 timestamp 與 close（同 line 7251 路徑修補理由）
                            const _pairs = (ch?.indicators?.quote?.[0]?.close ?? []).map((cv, i) => ({ ts: tss[i], close: cv })).filter(p => p.close != null);
                            if (_pairs.length === 0) continue; // chart API 無資料，跳過此標的（不設 marketOpenedToday）
                            const closes = _pairs.map(p => p.close);
                            const _tzPC = _exchangeTz(holding);
                            const todayET = new Date().toLocaleDateString('en-US', {timeZone: _tzPC});
                            const barET = new Date(_pairs[_pairs.length - 1].ts * 1000).toLocaleDateString('en-US', {timeZone: _tzPC});
                            const opened = (todayET === barET);
                            _tmpMarketOpened[holding] = opened;
                            const adjCl = closes.slice();
                            if (!opened) { while (adjCl.length >= 2 && adjCl[adjCl.length-1] === adjCl[adjCl.length-2]) adjCl.pop(); }
                            if (opened) {
                                if (adjCl.length >= 2) _tmpPrevClose[holding]     = adjCl[adjCl.length - 2];
                                if (adjCl.length >= 3) _tmpPrevPrevClose[holding] = adjCl[adjCl.length - 3];
                            } else {
                                if (adjCl.length >= 1) _tmpPrevClose[holding]     = adjCl[adjCl.length - 1];
                                if (adjCl.length >= 2) _tmpPrevPrevClose[holding] = adjCl[adjCl.length - 2];
                            }
                            if (allResults[query]) {
                                allResults[query].prevClose         = _tmpPrevClose[holding] ?? allResults[query].prevClose;
                                allResults[query].prevPrevClose     = _tmpPrevPrevClose[holding] ?? allResults[query].prevPrevClose;
                                allResults[query].marketOpenedToday = opened;
                            }
                        } catch(_) {}
                        if (mi < missingSyms.length - 1) await new Promise(res => setTimeout(res, 150));
                    }
                }

                // 槓桿 ETF：必須抓自身日線取昨收（原型股昨收≠ETF昨收）
                // 技術面刷新路徑已用 fetchTechDataFromYahoo 處理，此區段僅在完整抓取時執行
                if (!fundFresh) {
                    const BASE1_lev = 'https://query1.finance.yahoo.com';
                    const proxyRows = rows.filter(r => r.isProxy);
                    for (let pi = 0; pi < proxyRows.length; pi++) {
                        const r = proxyRows[pi];
                        try {
                            // range=5d：偵測今日開盤 & prevPrevClose
                            const data  = await yfFetch(`${BASE1_lev}/v8/finance/chart/${r.holding}?interval=1d&range=5d`);
                            const res0  = data?.chart?.result?.[0];
                            const ts    = res0?.timestamp ?? [];
                            const rawCloses = res0?.indicators?.quote?.[0]?.close ?? [];
                            const _chartCcy = res0?.meta?.currency ?? '';
                            const _ccyScale = (HK_USD_PRICED.has(r.holding) && _chartCcy === 'HKD')
                                ? (exchangeRates.HKD_TWD / exchangeRates.USD_TWD) : 1;
                            // v15.080 後續修補：zip + filter 對齊 timestamp 與 close（盤中 close=null 時 ts/closes 對不齊會誤判 todayOpened）
                            const _pairs = rawCloses.map((cv, i) => ({ ts: ts[i], close: cv })).filter(p => p.close != null);
                            const closes = _pairs.map(p => p.close * _ccyScale);
                            const lastTs   = _pairs.length > 0 ? _pairs[_pairs.length - 1].ts : null;
                            const _tz = _exchangeTz(r.holding);
                            const todayET  = new Date().toLocaleDateString('en-US', {timeZone: _tz});
                            const barET    = lastTs ? new Date(lastTs * 1000).toLocaleDateString('en-US', {timeZone: _tz}) : '';
                            const todayOpened = (todayET === barET);
                            _tmpMarketOpened[r.holding] = todayOpened;
                            if (todayOpened) {
                                // 今日開盤：range=1d chartPreviousClose 取昨收（跨越空白交易日仍準確）
                                let prevCloseFrom1d = null;
                                try {
                                    const d1   = await yfFetch(`${BASE1_lev}/v8/finance/chart/${r.holding}?interval=1d&range=1d`);
                                    const m1   = d1?.chart?.result?.[0]?.meta;
                                    const _sc1 = (HK_USD_PRICED.has(r.holding) && (m1?.currency ?? '') === 'HKD')
                                        ? (exchangeRates.HKD_TWD / exchangeRates.USD_TWD) : 1;
                                    if (m1?.chartPreviousClose != null) prevCloseFrom1d = m1.chartPreviousClose * _sc1;
                                } catch(_) {}
                                _tmpPrevClose[r.holding]     = prevCloseFrom1d ?? (closes.length >= 2 ? closes[closes.length - 2] : null);
                                _tmpPrevPrevClose[r.holding] = closes.length >= 3 ? closes[closes.length - 3] : null;
                            } else {
                                const adjCls = closes.slice();
                                while (adjCls.length >= 2 && adjCls[adjCls.length-1] === adjCls[adjCls.length-2]) adjCls.pop();
                                if (adjCls.length >= 1) _tmpPrevClose[r.holding]     = adjCls[adjCls.length - 1];
                                if (adjCls.length >= 2) _tmpPrevPrevClose[r.holding] = adjCls[adjCls.length - 2];
                            }
                            allResults[r.holding] = {
                                prevClose: _tmpPrevClose[r.holding] ?? null,
                                prevPrevClose: _tmpPrevPrevClose[r.holding] ?? null,
                                marketOpenedToday: todayOpened
                            };
                        } catch(_) {}
                        if (pi < proxyRows.length - 1) await new Promise(res => setTimeout(res, 300));
                    }
                }

                // ── 最終快取存檔（含補抓後的 prevClose & ETF prevClose）──
                if (!fundFresh) {
                    _saveCache(allResults);      // 完整路徑：更新兩個 timestamp
                } else {
                    _saveTechCache(allResults);  // 技術面路徑：只更新 tech_ts
                }
            }

            // v15.081：所有資料抓取完畢 → merge 進全域快取（不整包覆蓋）
            // 既有 _prevCloseCache 可能已被 _hydratePrevCloseFromBaselines 寫入經 marketDate guard 驗證的 system baseline，
            // 不可被 fundamentals.json / chart 補抓的舊值蓋掉。merge 後再呼叫 _hydratePrevCloseFromBaselines 確保
            // system baseline（驗證過 marketDate）優先於 analysis baseline。
            window._prevCloseCache     = { ...(window._prevCloseCache     || {}), ..._tmpPrevClose };
            window._prevPrevCloseCache = { ...(window._prevPrevCloseCache || {}), ..._tmpPrevPrevClose };
            window._marketOpenedToday  = { ...(window._marketOpenedToday  || {}), ..._tmpMarketOpened };
            try { _hydratePrevCloseFromBaselines(); } catch(_) {}

            // v15.073：runAnalysis 跑完，prevClose / prevPrevClose 對齊到各市場 lastCompletedTradingDate
            // 標 analysis meta（不是 quote meta；v15.072 已移除 _markBatchQuoteRefresh，這裡延續不再呼叫）
            try { _markAnalysisRefresh(['TW', 'HK', 'US']); } catch(_) {}

            renderAll(); // 更新持倉管理的當日損益欄位

            // ── 顯示基本面 & 技術面各自的最後更新時間 ──
            {
                const gen = window._fundJsonCache?.generated;
                const raw = _loadCacheRaw();
                const fundTs = gen || raw.fund_ts || null;
                const techTs = raw.tech_ts || Date.now();
                _updateSourceTimes(fundTs, techTs);
            }
            _lastAnalysisLoad = Date.now(); // 記錄完成時間，供 switchTab 判斷是否需要重整
        }
        // ==================== 初始化 ====================
        function init() {
            holdings = [];
            _storageReady = false; // 還原期間禁止寫入
            // v13：優先從 localStorage 還原上次持倉
            const hadSaved = loadFromStorage();
            _storageReady = true;  // 還原完成，開放寫入
            loadSheetUrlSetting(); // 還原雲端 CSV 路徑設定
            loadGistSettings();      // 還原 Gist Token & ID
            loadCash();
            loadDeposits();          // 還原存款資料
            loadCrypto();            // 還原加密倉位設定
            loadMoxa();              // 還原 MOXA 股票設定
            loadWatchlist();         // 還原觀察清單
            loadTradeHistory();      // 還原已實現損益紀錄
            // v15.076 / v15.077：沒填 GIST 且 FSA 未啟用時 → 預設清空已實現損益（避免跨裝置切換時顯示陳舊資料）
            // 有 GIST → silent pull 會拉雲端 tradeHistory；有 FSA → silent pull 從本地檔載入
            const _hasGistInit = !!localStorage.getItem(GIST_TOKEN_KEY) && !!localStorage.getItem(GIST_ID_KEY);
            // v15.078 codex P3：共用 _isFsaSupported()，避免 mobile 殘留 localSyncEnabled='1' 時 _hasFsaInit 誤回 true
            const _hasFsaInit  = !_hasGistInit
                              && _isFsaSupported()
                              && localStorage.getItem(STORAGE_KEYS.localSyncEnabled) === '1';
            if (!_hasGistInit && !_hasFsaInit) {
                if (tradeHistory.length > 0) {
                    tradeHistory = [];
                    try { saveTradeHistory(); } catch(_) {}
                }
            }
            loadSnapshots();         // 還原月度市值快照
            holdings.forEach(_ensureLots); // 舊資料向下相容：補齊 lots 欄位
            loadPrivacy();           // 還原隱私模式設定
            loadFont();              // 還原字型設定
            setCurrency(currency); // 同步按鈕高亮（預設 TWD，或從 localStorage 還原的值）

            // v15.069：抽成 _hydrateDailyPnlCachesFromAnalysisCache，Gist pull 後也能呼叫
            _hydrateDailyPnlCachesFromAnalysisCache();

            renderAll();
            // 有 Gist 憑證時跳過本地 toast（auto-pull 成功後會顯示雲端 toast）
            const _hasGistCreds = !!localStorage.getItem(GIST_TOKEN_KEY) && !!localStorage.getItem(GIST_ID_KEY);
            if (hadSaved && !_hasGistCreds) {
                showImportToast(`✅ 已還原上次持倉（${holdings.length} 筆）`, 3500);
            }
            console.log('%c✅ Portfolio Tracker v15 已啟動', 'color:#10b981; font-size:14px;');
            // v15.075：啟動無條件呼叫 _gistSilentPull，由 classify 決定要 pull / 觸發 push / 報衝突
            // 取代舊的「pending > 0 → 先推後拉，push 失敗就卡死」分支
            _updatePendingPushIndicator();
            _renderRollbackCard();   // v15.079：若本機有 master rollback summary 則顯示卡片
            _gistSilentPull();
            // v15.080：啟動 + silent pull 後 8 秒，若本機今日損益仍缺 prevClose（_dailyPnlBaselines 為空），啟動 backfill
            //   只在有 holdings 時觸發；fail-safe：cooldown 已自帶
            setTimeout(() => {
                try {
                    if (Array.isArray(holdings) && holdings.length > 0) {
                        const hasBaseline = _dailyPnlBaselines && _dailyPnlBaselines.symbols && Object.keys(_dailyPnlBaselines.symbols).length > 0;
                        if (!hasBaseline) _backfillDailyPnlSystemData('startup_no_baseline');
                    }
                } catch(_) {}
            }, 8000);
            // v15.077 → v15.078 hotfix：FSA silent pull — 只在權限 granted 時自動拉
            // 移除原本「全域 click/keydown capture handler 自動 requestPermission」的 hack（會在 Android Chrome 卡死整個 UI）
            // 權限過期時：只顯示 status 提示，user 必須到設定 Tab → 本地同步 → 主動點「拉取」按鈕重新授權
            (async () => {
                try {
                    if (_hasGistCreds()) { _renderLocalSyncStatus(); return; }
                    if (!_isLocalSyncEnabled()) { _renderLocalSyncStatus(); return; }
                    const handle = await _localSyncGetDirNoPrompt();
                    if (handle) {
                        await _localSyncPull({ manual: false });
                        _renderLocalSyncStatus();
                        return;
                    }
                    // 權限過期：僅 status 提示，不註冊任何全域 listener
                    _setLocalSyncStatus('⚠ 本地資料夾權限已過期，請到設定 Tab → 本地同步 → 點「從本地拉取」重新授權', '#fbbf24');
                    _renderLocalSyncStatus();
                } catch(_) {}
            })();
            // 啟動時自動抓取即時匯率（快取 1hr 內直接用快取，不打 API）
            (async () => {
                const fx = await _fetchFxRates(false);
                if (fx) {
                    exchangeRates.USD_TWD = fx.USD_TWD;
                    exchangeRates.HKD_TWD = fx.HKD_TWD;
                    syncRateInputs();
                    const rateEl = document.getElementById('rate-source');
                    if (rateEl) {
                        const t = new Date(fx.ts).toLocaleTimeString('zh-TW', { hour:'2-digit', minute:'2-digit' });
                        rateEl.textContent = fx.fromCache
                            ? `✓ 即時匯率（${t} · 快取 ${_fxAgeStr(fx.ts)}）`
                            : `✓ 即時匯率（${new Date().toLocaleTimeString('zh-TW')}）`;
                        // v15.063：匯率快取年齡套色
                        rateEl.style.color = fx.fromCache
                            ? _freshnessColor(Date.now() - fx.ts, 30*60*1000, 90*60*1000)
                            : '#7e93a6';
                    }
                    renderAll();
                    recordSnapshot(); // 每月首次開啟，自動記錄市值快照
                }
            })();
            // 啟動時抓取 USDT/TWD 匯率（CoinGecko）
            fetchUsdtRate();

            // v15.064：Render warm-up；BACKEND_URL 已設定才打 /health（本機強制空白會跳過）。
            // v15.065 修補：用 try/catch + AbortController 降級，避免 iOS Safari < 17.4 / 舊 Chrome
            //   缺 AbortSignal.timeout API 時 sync throw 中斷後續啟動序列（startAutoRefresh 等）。
            (function _renderWarmUp() {
                if (!BACKEND_URL) return;
                try {
                    const ctrl = new AbortController();
                    const tid = setTimeout(() => ctrl.abort(), 60000);
                    fetch(BACKEND_URL + '/health', { cache: 'no-store', signal: ctrl.signal })
                        .then(r => { clearTimeout(tid); if (!r.ok) throw new Error('HTTP ' + r.status); })
                        .catch(e => { clearTimeout(tid); try { _recordAppError('render_health', e); } catch(_) {} });
                } catch(e) {
                    try { _recordAppError('render_health', e); } catch(_) {}
                }
            })();

            // v15.066：PWA 版本更新偵測；5 分鐘後第一次檢查、之後每 30 分鐘
            // 直接拿 APP_VERSION 對網路 HTML 版本字串比對（baseline 不依賴第一次抓的值）
            setTimeout(() => {
                _checkAppVersion();
                _versionCheckTimer = setInterval(_checkAppVersion, 30 * 60 * 1000);
            }, 5 * 60 * 1000);

            // v15.064：頁面啟動時更新錯誤日誌計數
            try { _renderErrorLogCount(); } catch(_) {}
            // 啟動每分鐘自動更新報價
            startAutoRefresh();
            // 啟動後台自動更新（技術面1hr / 基本面4hr，由快取TTL決定刷新範圍）
            startAutoAnalysis();
            // 啟動財報分析後台更新（每12hr）
            startAutoEarnings();
            // 啟動總體經濟後台更新（每1hr）
            startAutoMacro();
            // 有持倉時：延遲 2 秒靜默預載分析（讓主畫面先渲染完）
            if (hadSaved && holdings.length > 0) {
                setTimeout(() => loadAnalysis(false, true), 2000);
            }

            // ── 分頁隱藏時暫停所有計時器，切回後恢復（減少背景 CPU/記憶體佔用）──
            document.addEventListener('visibilitychange', () => {
                if (document.hidden) {
                    clearInterval(_autoRefreshTimer);
                    clearInterval(_countdownTimer);
                    clearInterval(_autoAnalysisTimer);
                    clearInterval(_autoMacroTimer);
                    clearInterval(_autoEarningsTimer);
                } else {
                    startAutoRefresh();
                    startAutoAnalysis();
                    startAutoMacro();
                    startAutoEarnings();
                }
            });
        }
        window.onload = init;

        // 持倉一覽 / 基本面 / 技術面 row 點選鎖定
        document.addEventListener('click', function(e) {
            const holdingsTr = e.target.closest('#holdings-table tbody tr');
            const analysisTr = e.target.closest('#tab-pane-2 table tbody tr, #tab-pane-3 table tbody tr');
            if (holdingsTr) {
                const sym = holdingsTr.dataset.symbol;
                _selectedHoldingSymbol = (_selectedHoldingSymbol === sym) ? null : sym;
                _applyHoldingRowSelection();
            } else if (analysisTr) {
                const sym = analysisTr.dataset.symbol;
                _selectedAnalysisSymbol = (_selectedAnalysisSymbol === sym) ? null : sym;
                _applyAnalysisRowSelection();
            } else {
                if (_selectedHoldingSymbol) { _selectedHoldingSymbol = null; _applyHoldingRowSelection(); }
                if (_selectedAnalysisSymbol) { _selectedAnalysisSymbol = null; _applyAnalysisRowSelection(); }
            }
        });

        // v15.076：持倉一覽桌機雙擊 / 行動裝置使用 row 內按鈕，把 symbol + market 填入交易表單
        function _fillTradeForm(symbol, market) {
            const sEl = document.getElementById('form-symbol');
            const mEl = document.getElementById('form-market');
            const qEl = document.getElementById('form-quantity');
            const cEl = document.getElementById('form-cost');
            if (!sEl || !mEl) return;
            sEl.value = symbol || '';
            mEl.value = market || 'US';
            try { if (typeof onMarketChange === 'function') onMarketChange(mEl.value); } catch(_) {}
            try { if (typeof onSymbolInput  === 'function') onSymbolInput(sEl.value);  } catch(_) {}
            if (qEl) qEl.value = '';
            if (cEl) cEl.value = '';
            // v15.077：移除 qEl.focus() — 手機 tap 持倉按鈕後不應自動彈鍵盤打斷 user
            try { showImportToast(`已填入 ${symbol}`, 1500); } catch(_) {}
        }
        // 桌機雙擊持倉一覽 row → 填表（避開按鈕本身的 click 鎖定行為）
        document.addEventListener('dblclick', function(e) {
            const tr = e.target.closest('#holdings-table tbody tr[data-symbol]');
            if (!tr) return;
            const symbol = tr.dataset.symbol;
            const h = holdings.find(x => x.symbol === symbol);
            if (!h) return;
            _fillTradeForm(h.symbol, h.market);
        });

        // ==================== 每分鐘自動更新報價 ====================
        let _autoRefreshTimer = null;
        let _countdownTimer   = null;
        let _secondsLeft      = 60;

        function startAutoRefresh() {
            if (_autoRefreshTimer) clearInterval(_autoRefreshTimer);
            if (_countdownTimer)   clearInterval(_countdownTimer);

            // 每 60 秒抓一次報價
            _autoRefreshTimer = setInterval(async () => {
                const url = (document.getElementById('sheet-url')?.value || '').trim();
                if (!url || !url.includes('docs.google.com')) return;
                if (document.getElementById('refresh-btn')?.disabled) return; // 手動更新中，跳過
                await silentRefreshPrices();
                _secondsLeft = 60; // 重置倒數
            }, 60000);

            // 每秒更新倒數顯示 & 顯示/隱藏狀態列
            _countdownTimer = setInterval(() => {
                const url = (document.getElementById('sheet-url')?.value || '').trim();
                const hasSheet = url && url.includes('docs.google.com');
                const statusEl = document.getElementById('auto-refresh-status');
                if (statusEl) statusEl.style.display = hasSheet ? 'block' : 'none';
                if (!hasSheet) { _secondsLeft = 60; return; }
                _secondsLeft = Math.max(1, _secondsLeft - 1);
                const cd = document.getElementById('auto-refresh-countdown');
                if (cd) cd.textContent = _secondsLeft;
            }, 1000);
        }

        // ── 偵測新標的並提示更新 symbols.json ──
        async function _showMissingFundNotice(missingSymbols) {
            // 取得目前 symbols.json
            let currentSymbols = [];
            try {
                const r = await fetch('./data/symbols.json');
                if (r.ok) currentSymbols = await r.json();
            } catch(_) {}

            // 合併新標的（去重）
            const merged = [...new Set([...currentSymbols, ...missingSymbols])];
            const newOnes = missingSymbols.filter(s => !currentSymbols.includes(s));
            if (newOnes.length === 0) return; // 都已在 symbols.json 裡

            // 建立提示 Toast（帶下載按鈕）
            const notice = document.createElement('div');
            notice.id = 'missing-fund-notice';
            Object.assign(notice.style, {
                position:'fixed', bottom:'1.5rem', left:'50%', transform:'translateX(-50%)',
                background:'rgba(15,40,80,0.97)', border:'1.5px solid rgba(56,139,253,0.5)',
                color:'#e2e8f0', padding:'0.9rem 1.2rem', borderRadius:'14px',
                fontSize:'0.88rem', zIndex:'9999', maxWidth:'92vw',
                boxShadow:'0 6px 24px rgba(0,0,0,0.6)', lineHeight:'1.6',
                display:'flex', flexDirection:'column', gap:'0.55rem'
            });
            notice.innerHTML = `
                <div style="color:#60a5fa;font-weight:700;">⚠ 新標的尚無基本面資料</div>
                <div>以下標的不在 <code>data/symbols.json</code> 中，基本面欄位顯示 "-"：<br>
                    <span style="color:#3b82f6;font-weight:600;">${newOnes.join('、')}</span></div>
                <div style="display:flex;gap:0.5rem;flex-wrap:wrap;">
                    <button id="sync-symbols-btn" onclick="_syncSymbols(${JSON.stringify(merged).replace(/"/g,'&quot;')})"
                        style="flex:1;padding:0.45rem 0.8rem;background:linear-gradient(135deg,#60a5fa,#3b82f6);
                               color:#060d1a;font-weight:700;border:none;border-radius:8px;cursor:pointer;font-size:0.85rem;min-width:140px;">
                        ↻ 一鍵更新清單</button>
                    <button onclick="document.getElementById('missing-fund-notice')?.remove()"
                        style="padding:0.45rem 0.8rem;background:rgba(100,116,139,0.3);color:#a8bdd0;
                               border:1px solid rgba(100,116,139,0.3);border-radius:8px;cursor:pointer;font-size:0.85rem;">
                        略過</button>
                </div>
                <div style="color:#7e93a6;font-size:0.78rem;">更新後基本面資料將於下次排程自動補齊。</div>`;
            // 移除舊的通知
            document.getElementById('missing-fund-notice')?.remove();
            document.body.appendChild(notice);
        }

        async function _syncSymbols(merged) {
            const btn = document.getElementById('sync-symbols-btn');
            // 優先用 Cloudflare Worker（寫死），沒有才退回 backend_url
            const WORKER_URL = 'https://syncsymbols.forsmileangel.workers.dev';
            const updateUrl = WORKER_URL || localStorage.getItem('backend_url') || '';
            if (!updateUrl) {
                showImportToast('⚠️ 請先設定後端網址', 3000); return;
            }
            if (btn) { btn.disabled = true; btn.textContent = '⏳ 更新中...'; }
            try {
                const resp = await fetch(updateUrl + '/update-symbols', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(merged)
                });
                const result = await resp.json();
                if (result.ok) {
                    document.getElementById('missing-fund-notice')?.remove();
                    showImportToast('✅ 清單已更新', 2500);
                } else {
                    showImportToast('❌ 更新失敗：' + (result.error || '未知錯誤'), 4000);
                    if (btn) { btn.disabled = false; btn.textContent = '↻ 一鍵更新清單'; }
                }
            } catch(e) {
                showImportToast('❌ 連線失敗，請確認後端設定', 4000);
                if (btn) { btn.disabled = false; btn.textContent = '↻ 一鍵更新清單'; }
            }
        }

        // ── 後台自動更新：財報分析每12小時 ──
        let _autoEarningsTimer = null;
        function startAutoEarnings() {
            if (_autoEarningsTimer) clearInterval(_autoEarningsTimer);
            _autoEarningsTimer = setInterval(async () => {
                if (holdings.length === 0) return;
                const btn = document.getElementById('earnings-btn');
                if (btn?.disabled) return;
                await loadEarningsAnalysis(false); // 12hr TTL 內直接跳過
            }, 12 * 60 * 60 * 1000); // 每 12 小時
        }

        // ── 後台自動更新：總體經濟每1小時 ──
        let _autoMacroTimer = null;
        function startAutoMacro() {
            if (_autoMacroTimer) clearInterval(_autoMacroTimer);
            _autoMacroTimer = setInterval(async () => {
                const btn = document.getElementById('macro-btn');
                if (btn?.disabled) return;
                await loadMacro(false); // 1hr TTL 內直接跳過
            }, 60 * 60 * 1000); // 每 1 小時
        }

        // ── 後台自動更新：技術面每1小時、基本面每4小時（由 loadAnalysis 快取判斷決定更新範圍）──
        let _autoAnalysisTimer = null;
        function startAutoAnalysis() {
            if (_autoAnalysisTimer) clearInterval(_autoAnalysisTimer);
            _autoAnalysisTimer = setInterval(async () => {
                if (holdings.length === 0) return;
                const btn = document.getElementById('analysis-btn');
                if (btn?.disabled) return; // 已在更新中，跳過
                window._fundJsonCache = null; // 釋放上次快取，下次重新讀取最新 fundamentals.json
                // forceRefresh=false → 讓 loadAnalysis 依快取 TTL 決定更新範圍
                // 技術面(1hr)或基本面(4hr)過期時自動刷新；均有效時直接跳過
                await loadAnalysis(false, true); // silent=true 不顯示 loading 狀態
                // 後台更新完成 → 刷新時間顯示
                {
                    const gen = window._fundJsonCache?.generated;
                    const raw = _loadCacheRaw();
                    _updateSourceTimes(gen || raw.fund_ts || null, raw.tech_ts || null);
                }
            }, 60 * 60 * 1000); // 每 1 小時觸發一次（判斷是否需要更新）
        }

        // ==================== Tab 4：財報分析 & 券商評級 ====================
        let _earningsLoaded = false;
        const _QS_CACHE_KEY = 'pf_qs_v5';           // v5：加入券商目標價區塊，強制清除舊快取
        const _QS_CACHE_TTL = 12 * 60 * 60 * 1000; // 財報分析：12 小時
        function _loadQsCache() {
            try { const r = JSON.parse(localStorage.getItem(_QS_CACHE_KEY)||'{}'); return (Date.now()-(r.ts||0) < _QS_CACHE_TTL) ? (r.data||{}) : {}; } catch { return {}; }
        }
        function _isQsCacheFresh() {
            try { const r = JSON.parse(localStorage.getItem(_QS_CACHE_KEY)||'{}'); return (Date.now()-(r.ts||0) < _QS_CACHE_TTL); } catch { return false; }
        }
        function _saveQsCache(data) {
            try { localStorage.setItem(_QS_CACHE_KEY, JSON.stringify({ts:Date.now(), data})); } catch {}
        }

        // ── 總體經濟快取（1小時）──
        const _MACRO_CACHE_KEY = 'pf_macro_v1';
        const _MACRO_CACHE_TTL = 60 * 60 * 1000; // 1 小時
        function _loadMacroCache() {
            try { const r = JSON.parse(localStorage.getItem(_MACRO_CACHE_KEY)||'{}'); return (Date.now()-(r.ts||0) < _MACRO_CACHE_TTL) ? r : null; } catch { return null; }
        }
        function _isMacroCacheFresh() {
            try { const r = JSON.parse(localStorage.getItem(_MACRO_CACHE_KEY)||'{}'); return (Date.now()-(r.ts||0) < _MACRO_CACHE_TTL); } catch { return false; }
        }
        function _saveMacroCache(results, news) {
            try { localStorage.setItem(_MACRO_CACHE_KEY, JSON.stringify({ts:Date.now(), results, news})); } catch {}
        }

        async function loadEarningsAnalysis(forceRefresh) {
            if (holdings.length === 0) { alert('請先匯入持倉數據'); return; }
            const btn = document.getElementById('earnings-btn');
            const statusEl = document.getElementById('earnings-status');
            if (btn) { btn.textContent = '載入中...'; btn.disabled = true; }

            const symbols = [...new Set(_allAnalysisTargets().map(h => getQuerySymbol(h.symbol)))];
            const cache = forceRefresh ? {} : _loadQsCache();
            const allQs = { ...cache };

            // 全域快取補充（localStorage 沒有的標的，從 cache.json 補）
            if (!forceRefresh) {
                try {
                    const gc = await _loadGlobalCache();
                    const gcE = gc?.earnings || {};
                    for (const sym of symbols) {
                        if (!allQs[sym] && gcE[sym] &&
                            (Date.now() - (gcE[sym].fetched_at || 0)) < _QS_CACHE_TTL) {
                            allQs[sym] = gcE[sym].data;
                        }
                    }
                } catch(_) {}
            }

            const toFetch = symbols.filter(s => !allQs[s]);

            // 逐一查詢（循序，避免代理 rate limit）
            // 使用週線 v8/chart?events=earnings → 免認證取得近8季 EPS Actual/Estimate
            // Yahoo Finance v6/v7/v10 quote API 均需 crumb 認證，已全面停用。
            for (let i = 0; i < toFetch.length; i++) {
                const sym = toFetch[i];
                if (statusEl) statusEl.textContent = `(${i+1}/${toFetch.length}) 查詢 ${sym}...`;
                try {
                    const chartData = await yfFetch(
                        `https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(sym)}?interval=1wk&range=2y&events=earnings`
                    ).catch(() => null);
                    if (!chartData) { allQs[sym] = { _error: '無法取得數據' }; continue; }

                    // 從 chart events 轉換成 earningsHistory.history 格式
                    const rawEvents = chartData?.chart?.result?.[0]?.events?.earnings ?? {};
                    const earningsHistoryArr = Object.entries(rawEvents)
                        .sort(([a],[b]) => Number(a) - Number(b))
                        .map(([ts, e]) => {
                            const actualVal = e.epsActual  ?? e.actual  ?? null;
                            const estVal    = e.epsEstimate ?? e.estimate ?? null;
                            const surpRaw   = e.epsSurprisePct ?? e.surprisePct ?? null;
                            const calcSurp  = (actualVal != null && estVal != null && estVal !== 0)
                                ? (actualVal - estVal) / Math.abs(estVal) : null;
                            const d = new Date(Number(ts) * 1000);
                            const qNum = Math.ceil((d.getMonth() + 1) / 3);
                            return {
                                epsActual:       { raw: actualVal },
                                epsEstimate:     { raw: estVal },
                                surprisePercent: { raw: surpRaw != null ? surpRaw / 100 : calcSurp },
                                quarter:         { fmt: `${d.getFullYear()} Q${qNum}` }
                            };
                        });

                    allQs[sym] = {
                        earningsHistory:         { history: earningsHistoryArr },
                        upgradeDowngradeHistory: { history: [] },
                        financialData: {
                            recommendationKey: '', numberOfAnalystOpinions: { raw: 0 },
                            targetMeanPrice: null, targetLowPrice: null, targetHighPrice: null,
                            grossMargins: null, operatingMargins: null, revenueGrowth: null,
                        },
                    };
                } catch(e) {
                    allQs[sym] = { _error: e.message.split('\n')[0] };
                }
                if (i < toFetch.length - 1) await new Promise(r => setTimeout(r, 400));
            }
            _saveQsCache(allQs);

            // 回寫全域快取（有後端時非同步推送）
            try {
                const gc = await _loadGlobalCache();
                if (!gc.earnings) gc.earnings = {};
                for (const sym of symbols) {
                    if (allQs[sym] && !allQs[sym]._error) {
                        gc.earnings[sym] = { data: allQs[sym], fetched_at: Date.now() };
                    }
                }
                _globalCacheDirty = true;
                _pushGlobalCache();
            } catch(_) {}

            // ── 從 fundamentals.json 補充遺漏的季度 EPS 歷史與財務指標 ──────
            // 原因：CORS 代理不回傳 Yahoo Finance 的 events.earnings 欄位；
            //       Python 腳本透過 yfinance.earnings_dates 直接取得並存入 fundamentals.json
            if (!window._fundJsonCache) {
                try {
                    const r = await fetch('./data/fundamentals.json', { cache: 'no-store' });
                    if (r.ok) {
                        const txt = await r.text();
                        const cleaned = txt.replace(/:\s*NaN/g, ': null')
                                           .replace(/:\s*Infinity/g, ': null')
                                           .replace(/:\s*-Infinity/g, ': null');
                        window._fundJsonCache = JSON.parse(cleaned);
                    } else { window._fundJsonCache = {}; }
                } catch { window._fundJsonCache = {}; }
            }
            for (const sym of symbols) {
                // 若此 symbol 完全無資料，建立空殼（避免 renderEarningsTab 跳過）
                if (!allQs[sym]) {
                    allQs[sym] = {
                        earningsHistory: { history: [] },
                        upgradeDowngradeHistory: { history: [] },
                        financialData: { recommendationKey: '', numberOfAnalystOpinions: { raw: 0 } }
                    };
                }
                if (allQs[sym]._error) continue;
                const fj = window._fundJsonCache?.data?.[sym];
                if (!fj) continue;
                // 補充季度 EPS 歷史（API 空結果時從 fundamentals.json 讀取）
                const eh = allQs[sym].earningsHistory?.history ?? [];
                if (eh.length === 0 && fj.earnings_history?.length > 0) {
                    allQs[sym].earningsHistory = {
                        history: fj.earnings_history.map(e => ({
                            epsActual:       { raw: e.eps_actual },
                            epsEstimate:     { raw: e.eps_estimate },
                            surprisePercent: { raw: e.surprise_pct },
                            quarter:         { fmt: e.quarter }
                        }))
                    };
                }
                // 補充財務指標
                const fd = allQs[sym].financialData || {};
                allQs[sym].financialData = fd;
                if (fd.grossMargins?.raw    == null && fj.gross_margin     != null) fd.grossMargins    = { raw: fj.gross_margin };
                if (fd.operatingMargins?.raw == null && fj.operating_margin != null) fd.operatingMargins = { raw: fj.operating_margin };
                if (fd.revenueGrowth?.raw   == null && fj.rev_yoy          != null) fd.revenueGrowth   = { raw: fj.rev_yoy };
                // 補充目標價（CORS proxy 常不回傳，從 fundamentals.json 補）
                if (fd.targetMeanPrice?.raw   == null && fj.target_mean_price   != null) fd.targetMeanPrice   = { raw: fj.target_mean_price };
                if (fd.targetLowPrice?.raw    == null && fj.target_low_price    != null) fd.targetLowPrice    = { raw: fj.target_low_price };
                if (fd.targetHighPrice?.raw   == null && fj.target_high_price   != null) fd.targetHighPrice   = { raw: fj.target_high_price };
                if (fd.targetMedianPrice?.raw == null && fj.target_median_price != null) fd.targetMedianPrice = { raw: fj.target_median_price };
                if ((fd.numberOfAnalystOpinions?.raw == null || fd.numberOfAnalystOpinions?.raw === 0) && fj.number_of_analysts != null)
                    fd.numberOfAnalystOpinions = { raw: fj.number_of_analysts };
                // 附加估值摘要供 renderEarningsTab 顯示
                allQs[sym]._fund = {
                    pe: fj.pe, fpe: fj.fpe, peg: fj.peg, ps: fj.ps, pb: fj.pb,
                    eps_ttm:  fj.eps_ttm,  eps_cur_q:  fj.eps_cur_q,
                    eps_next_q: fj.eps_next_q2,
                    eps_cur_y: fj.eps_cur_y, eps_next_y: fj.eps_next_y,
                    rev_yoy: fj.rev_yoy, rev_fwd: fj.rev_fwd,
                    gross_margin: fj.gross_margin, operating_margin: fj.operating_margin,
                    hist_avg_pe: fj.hist_avg_pe,
                    // 券商目標價
                    target_mean:   fj.target_mean_price,
                    target_low:    fj.target_low_price,
                    target_high:   fj.target_high_price,
                    target_median: fj.target_median_price,
                    n_analysts:    fj.number_of_analysts,
                    // 原型股昨收（供槓桿 ETF 目標價漲跌幅比較用）
                    prev_close:    fj.prev_close,
                };
            }

            // 同步毛利率/營益率（若 v6/quote 有提供）到基本面快取
            const analysisCache = _loadCache();
            let acUpdated = false;
            for (const sym of symbols) {
                const qs = allQs[sym];
                if (qs && !qs._error && analysisCache[sym]) {
                    const fd = qs.financialData;
                    if (fd) {
                        if (analysisCache[sym].gross_margin == null && fd.grossMargins?.raw != null) {
                            analysisCache[sym].gross_margin = fd.grossMargins.raw; acUpdated = true;
                        }
                        if (analysisCache[sym].operating_margin == null && fd.operatingMargins?.raw != null) {
                            analysisCache[sym].operating_margin = fd.operatingMargins.raw; acUpdated = true;
                        }
                    }
                }
            }
            if (acUpdated) _saveCache(analysisCache);

            // ── 取得各標的近90天分析師相關新聞 ───────────────────────────────
            // Yahoo Finance search API 透過 CORS 代理可無認證取得，過濾分析師關鍵字
            const _ANALYST_KW = ['upgrade', 'downgrade', 'target', 'analyst', 'price target',
                                  'outperform', 'underperform', 'overweight', 'underweight',
                                  'initiates', 'raises', 'cuts', 'rating', 'buy', 'sell',
                                  'hold', 'neutral', 'coverage'];
            const cutoff90d = Date.now()/1000 - 90*24*3600;
            // 使用既有翻譯快取（24hr）
            const _tCacheKeyNews = 'pf_news_trans_v1';
            let tCacheNews = {};
            try {
                const rawT = JSON.parse(localStorage.getItem(_tCacheKeyNews)||'{}');
                tCacheNews = (Date.now()-(rawT.ts||0) < 24*3600*1000) ? (rawT.data||{}) : {};
            } catch(_) {}
            let tCacheNewsUpdated = false;

            if (statusEl) statusEl.textContent = '取得分析師動態...';
            for (let ni = 0; ni < symbols.length; ni++) {
                const sym = symbols[ni];
                if (!allQs[sym] || allQs[sym]._error) { allQs[sym] = allQs[sym] || {}; allQs[sym].analystNews = []; continue; }
                try {
                    const newsData = await yfFetch(
                        `https://query1.finance.yahoo.com/v1/finance/search?q=${encodeURIComponent(sym)}&newsCount=15&quotesCount=0`
                    ).catch(() => null);
                    const analystItems = (newsData?.news || [])
                        .filter(n => (n.providerPublishTime||0) >= cutoff90d)
                        .filter(n => _ANALYST_KW.some(kw => (n.title||'').toLowerCase().includes(kw)))
                        .slice(0, 5);
                    // 翻譯標題（使用快取，跳過已翻譯的項目）
                    for (const item of analystItems) {
                        const orig = item.title || '';
                        if (!orig) { item.titleZh = orig; continue; }
                        if (tCacheNews[orig]) { item.titleZh = tCacheNews[orig]; continue; }
                        try {
                            const tr = await fetch(
                                `https://api.mymemory.translated.net/get?q=${encodeURIComponent(orig)}&langpair=en|zh-TW`,
                                { signal: AbortSignal.timeout(5000) }
                            );
                            if (tr.ok) {
                                const td = await tr.json();
                                item.titleZh = td?.responseData?.translatedText || orig;
                                tCacheNews[orig] = item.titleZh;
                                tCacheNewsUpdated = true;
                            } else { item.titleZh = orig; }
                        } catch(_) { item.titleZh = orig; }
                        await new Promise(r => setTimeout(r, 200));
                    }
                    allQs[sym].analystNews = analystItems;
                } catch(_) { allQs[sym].analystNews = []; }
                if (ni < symbols.length - 1) await new Promise(r => setTimeout(r, 300));
            }
            if (tCacheNewsUpdated) {
                // 限制最多 200 筆，避免 localStorage 無限成長
                const _entries = Object.entries(tCacheNews);
                if (_entries.length > 200) tCacheNews = Object.fromEntries(_entries.slice(-200));
                try { localStorage.setItem(_tCacheKeyNews, JSON.stringify({ts:Date.now(), data:tCacheNews})); } catch(_) {}
            }

            renderEarningsTab(allQs);
            _earningsLoaded = true;
            if (btn) { btn.textContent = '↻ 載入分析'; btn.disabled = false; }
            if (statusEl) statusEl.textContent = '更新於 ' + new Date().toLocaleTimeString('zh-TW');
        }

        // ── 券商評級／動作 → 中文對照表 ──
        const GRADE_ZH = {
            'Strong Buy':          '強烈買進',
            'Buy':                 '買進',
            'Outperform':          '優於大盤',
            'Overweight':          '增持',
            'Market Outperform':   '優於市場',
            'Sector Outperform':   '優於同業',
            'Positive':            '正面看好',
            'Accumulate':          '逢低買進',
            'Add':                 '加碼',
            'Neutral':             '中立',
            'Hold':                '持有',
            'Market Perform':      '同步大盤',
            'Equal Weight':        '均等持有',
            'Peer Perform':        '同業表現',
            'Sector Perform':      '同業表現',
            'In-Line':             '符合預期',
            'Underperform':        '弱於大盤',
            'Underweight':         '減持',
            'Market Underperform': '弱於市場',
            'Sector Underperform': '弱於同業',
            'Negative':            '負面看空',
            'Reduce':              '減碼',
            'Sell':                '賣出',
            'Strong Sell':         '強烈賣出',
        };
        const ACTION_ZH = {
            'up':   '上調',
            'down': '下調',
            'main': '維持',
            'init': '初評',
            'reit': '重申',
        };
        function gradeZh(g) { return (g && GRADE_ZH[g]) ? GRADE_ZH[g] : (g || '-'); }
        function actionZh(a) { return (a && ACTION_ZH[a]) ? ACTION_ZH[a] : (a || ''); }

        function renderEarningsTab(allQs) {
            const container = document.getElementById('earnings-list');
            if (!container) return;

            const recColors = { strong_buy:'#10b981', buy:'#6ee7b7', hold:'#94a3b8', sell:'#fb923c', strong_sell:'#ef4444' };
            const recLabels = { strong_buy:'⬆ 強烈買進', buy:'↑ 建議買進', hold:'→ 持有觀望', sell:'↓ 建議賣出', strong_sell:'⬇ 強烈賣出' };
            const ninetyDaysAgo = Date.now()/1000 - 90*24*3600;

            const html = _allAnalysisTargets().map(h => {
                const sym = getQuerySymbol(h.symbol);
                const qs  = allQs[sym];
                const isProxy = !!LEVERAGED_MAP[h.symbol];
                const isWatchlist = !!h._isWatchlist;
                const proxyLabel = isProxy ? `<span style="color:#3b82f6;font-size:0.74rem;font-weight:600;"> (查詢: ${sym})</span>` : '';
                const watchlistLabel = isWatchlist ? `<span style="color:#7e93a6;font-size:0.72rem;margin-left:0.4rem;background:rgba(56,139,253,0.08);padding:0.05rem 0.35rem;border-radius:4px;border:1px solid rgba(56,139,253,0.15);">觀察中</span>` : '';

                if (!qs) return '';
                if (qs._error) return `
                    <div style="background:rgba(15,30,60,0.5);border:1px solid rgba(239,68,68,0.2);border-radius:10px;padding:0.7rem 1rem;margin-bottom:0.5rem;">
                        <span style="color:#60a5fa;font-weight:700;">${h.symbol}</span>${proxyLabel}${watchlistLabel}
                        <span style="color:#ef4444;font-size:0.8rem;margin-left:0.75rem;">❌ ${qs._error}</span>
                    </div>`;

                const fd  = qs.financialData || {};
                const eh  = qs.earningsHistory?.history || [];
                const ugh = qs.upgradeDowngradeHistory?.history || [];

                // 分析師共識
                const recKey   = fd.recommendationKey || '';
                const nAna     = fd.numberOfAnalystOpinions?.raw || qs._fund?.n_analysts || 0;
                const tgtMean  = fd.targetMeanPrice?.raw  ?? qs._fund?.target_mean  ?? null;
                const tgtLow   = fd.targetLowPrice?.raw   ?? qs._fund?.target_low   ?? null;
                const tgtHigh  = fd.targetHighPrice?.raw  ?? qs._fund?.target_high  ?? null;
                const tgtMed   = fd.targetMedianPrice?.raw ?? qs._fund?.target_median ?? null;
                // 目標價漲跌幅：槓桿/代理 ETF 需用原型股價比較（非槓桿 ETF 本身股價）
                const refPrice = isProxy
                    ? (qs._fund?.prev_close ?? null)   // 原型股昨收（來自 fundamentals.json）
                    : (h.currentPrice > 0 ? h.currentPrice : null);
                const refLabel = isProxy ? `（原型 ${sym}）` : '';
                const upside   = tgtMean && refPrice ? ((tgtMean - refPrice) / refPrice * 100).toFixed(1) : null;
                const upsideLow  = tgtLow  && refPrice ? ((tgtLow  - refPrice) / refPrice * 100).toFixed(1) : null;
                const upsideHigh = tgtHigh && refPrice ? ((tgtHigh - refPrice) / refPrice * 100).toFixed(1) : null;
                const recColor = recColors[recKey] || '#94a3b8';
                const recLabel = recLabels[recKey] || (recKey ? recKey : '-');

                // 近90天分析師相關新聞（由 loadEarningsAnalysis 從 Yahoo Finance search API 取得）
                const analystNews = qs.analystNews || [];
                const recentUpg = ugh.filter(u => u.epochGradeDate >= ninetyDaysAgo).slice(0, 6);

                // 近4季 EPS 表格
                const earningsRows = eh.slice(-4).reverse().map(e => {
                    const actual = e.epsActual?.raw, est = e.epsEstimate?.raw, surp = e.surprisePercent?.raw;
                    const beat = surp != null ? surp > 0 : null;
                    return `<tr style="border-bottom:1px solid rgba(255,255,255,0.05);">
                        <td style="padding:0.28rem 0.45rem;color:#a8bdd0;font-size:0.78rem;">${e.quarter?.fmt||'-'}</td>
                        <td style="padding:0.28rem 0.45rem;text-align:right;color:#e2e8f0;font-size:0.8rem;">${est != null ? est.toFixed(2) : '-'}</td>
                        <td style="padding:0.28rem 0.45rem;text-align:right;font-weight:700;font-size:0.8rem;color:${beat===true?'#10b981':beat===false?'#ef4444':'#e2e8f0'};">${actual != null ? actual.toFixed(2) : '-'}</td>
                        <td style="padding:0.28rem 0.45rem;text-align:right;font-size:0.78rem;">${surp!=null?`<span style="padding:0.08rem 0.3rem;border-radius:4px;background:${beat?'rgba(16,185,129,0.12)':'rgba(239,68,68,0.12)'};color:${beat?'#10b981':'#ef4444'};">${beat?'+':''}${(surp*100).toFixed(1)}%</span>`:'-'}</td>
                    </tr>`;
                }).join('');

                // 毛利率/營益率/營收成長（來自 financialData 或 _fund）
                const gm  = fd.grossMargins?.raw, om = fd.operatingMargins?.raw, rg = fd.revenueGrowth?.raw;
                const marginPills = [
                    gm  != null ? `<span style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(59,130,246,0.1);color:#60a5fa;font-size:0.75rem;">毛利率 ${(gm*100).toFixed(1)}%</span>` : '',
                    om  != null ? `<span style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(99,102,241,0.1);color:#a5b4fc;font-size:0.75rem;">營益率 ${(om*100).toFixed(1)}%</span>` : '',
                    rg  != null ? `<span style="padding:0.1rem 0.4rem;border-radius:4px;background:${rg>=0?'rgba(16,185,129,0.1)':'rgba(239,68,68,0.1)'};color:${rg>=0?'#10b981':'#ef4444'};font-size:0.75rem;">營收成長 ${(rg*100).toFixed(1)}%</span>` : '',
                ].filter(Boolean).join('');

                // 估值 & EPS 預估（來自 fundamentals.json）
                const fnd = qs._fund || {};
                const fmtV = (v, decimals=2) => v != null ? v.toFixed(decimals) : '-';
                const fmtP = (v) => v != null ? `${(v*100).toFixed(1)}%` : '-';
                const valuationPills = [
                    fnd.pe  != null ? `<span title="本益比(TTM)" style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(30,58,110,0.2);color:#60a5fa;font-size:0.74rem;cursor:default;">PE ${fmtV(fnd.pe)}</span>` : '',
                    fnd.fpe != null ? `<span title="預期本益比" style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(30,58,110,0.2);color:#3b82f6;font-size:0.74rem;cursor:default;">FPE ${fmtV(fnd.fpe)}</span>` : '',
                    fnd.ps  != null ? `<span title="股價營收比" style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(148,163,184,0.08);color:#a8bdd0;font-size:0.74rem;cursor:default;">PS ${fmtV(fnd.ps)}</span>` : '',
                    fnd.pb  != null ? `<span title="股價淨值比" style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(148,163,184,0.08);color:#a8bdd0;font-size:0.74rem;cursor:default;">PB ${fmtV(fnd.pb)}</span>` : '',
                    fnd.peg != null ? `<span title="本益成長比" style="padding:0.1rem 0.4rem;border-radius:4px;background:rgba(148,163,184,0.08);color:#a8bdd0;font-size:0.74rem;cursor:default;">PEG ${fmtV(fnd.peg)}</span>` : '',
                    fnd.rev_fwd != null ? `<span title="預期營收成長" style="padding:0.1rem 0.4rem;border-radius:4px;background:${fnd.rev_fwd>=0?'rgba(16,185,129,0.08)':'rgba(239,68,68,0.08)'};color:${fnd.rev_fwd>=0?'#10b981':'#ef4444'};font-size:0.74rem;cursor:default;">預期營收 ${fmtP(fnd.rev_fwd)}</span>` : '',
                ].filter(Boolean).join('');

                // EPS 預估行（curQ / nextQ / curY / nextY）
                const epsRow = (fnd.eps_cur_q != null || fnd.eps_next_q != null || fnd.eps_cur_y != null || fnd.eps_next_y != null) ? `
                    <div style="margin-top:0.5rem;padding-top:0.45rem;border-top:1px solid rgba(255,255,255,0.06);">
                        <div style="color:#7e93a6;font-size:0.72rem;margin-bottom:0.3rem;">EPS 預估</div>
                        <div style="display:flex;gap:0.5rem;flex-wrap:wrap;">
                            ${fnd.eps_ttm    != null ? `<span style="font-size:0.76rem;color:#e2e8f0;">TTM <b style="color:#60a5fa;">${fmtV(fnd.eps_ttm)}</b></span>` : ''}
                            ${fnd.eps_cur_q  != null ? `<span style="font-size:0.76rem;color:#e2e8f0;">本季 <b style="color:#60a5fa;">${fmtV(fnd.eps_cur_q)}</b></span>` : ''}
                            ${fnd.eps_next_q != null ? `<span style="font-size:0.76rem;color:#e2e8f0;">下季 <b style="color:#60a5fa;">${fmtV(fnd.eps_next_q)}</b></span>` : ''}
                            ${fnd.eps_cur_y  != null ? `<span style="font-size:0.76rem;color:#e2e8f0;">今年 <b style="color:#a5b4fc;">${fmtV(fnd.eps_cur_y)}</b></span>` : ''}
                            ${fnd.eps_next_y != null ? `<span style="font-size:0.76rem;color:#e2e8f0;">明年 <b style="color:#a5b4fc;">${fmtV(fnd.eps_next_y)}</b></span>` : ''}
                        </div>
                    </div>` : '';

                // ── 券商目標價區塊（緊湊寬度，不佔滿全行）──────────────
                const upsideColor = upside != null ? (parseFloat(upside) >= 0 ? '#10b981' : '#ef4444') : '#94a3b8';
                const targetBlock = tgtMean ? (() => {
                    // 格式化目標價數字（KRW 等大數字用千分位，其餘保留小數）
                    const fmtTgt = v => {
                        if (v == null) return '-';
                        return v >= 1000 ? v.toLocaleString('en-US', {maximumFractionDigits: 0}) : v.toFixed(2);
                    };
                    // 視覺化進度條：原型股價在 low~high 之間的位置
                    let barHtml = '';
                    if (tgtLow != null && tgtHigh != null && refPrice != null && tgtHigh > tgtLow) {
                        const pct     = Math.max(0, Math.min(100, (refPrice - tgtLow) / (tgtHigh - tgtLow) * 100));
                        const meanPct = Math.max(0, Math.min(100, (tgtMean  - tgtLow) / (tgtHigh - tgtLow) * 100));
                        barHtml = `
                        <div style="margin-top:0.6rem;padding-top:0.5rem;border-top:1px solid rgba(96,165,250,0.12);">
                            <div style="position:relative;height:6px;border-radius:3px;
                                background:linear-gradient(to right,rgba(239,68,68,0.3),rgba(56,139,253,0.3),rgba(16,185,129,0.3));">
                                <div style="position:absolute;top:-4px;left:${meanPct}%;transform:translateX(-50%);
                                    width:2px;height:14px;background:#60a5fa;border-radius:1px;" title="平均目標 $${fmtTgt(tgtMean)}"></div>
                                <div style="position:absolute;top:50%;left:${pct}%;transform:translate(-50%,-50%);
                                    width:10px;height:10px;border-radius:50%;background:#60a5fa;
                                    border:2px solid #0f1e3c;box-shadow:0 0 5px #60a5fa90;"
                                    title="${isProxy?sym+'昨收':'目前股價'} $${fmtTgt(refPrice)}"></div>
                            </div>
                            <div style="display:flex;justify-content:space-between;margin-top:0.3rem;">
                                <span style="color:#7e93a6;font-size:0.69rem;">低 $${fmtTgt(tgtLow)}${upsideLow!=null?' ('+( parseFloat(upsideLow)>=0?'+':'')+upsideLow+'%)':''}</span>
                                <span style="color:#7e93a6;font-size:0.69rem;">高 $${fmtTgt(tgtHigh)}${upsideHigh!=null?' ('+(parseFloat(upsideHigh)>=0?'+':'')+upsideHigh+'%)':''}</span>
                            </div>
                        </div>`;
                    }
                    return `
                    <div style="display:inline-block;min-width:220px;max-width:340px;vertical-align:top;
                        background:rgba(96,165,250,0.07);border:1px solid rgba(96,165,250,0.2);
                        border-radius:8px;padding:0.6rem 0.85rem;margin-bottom:0.65rem;">
                        <!-- 標題行 -->
                        <div style="color:#a8bdd0;font-size:0.72rem;font-weight:600;margin-bottom:0.35rem;">
                            <i class="ic">◎</i> 券商平均目標價${isProxy?`<span style="color:#3b82f6;font-weight:400;font-size:0.69rem;"> · ${sym} 原型</span>`:''}
                        </div>
                        <!-- 主要數字行 -->
                        <div style="display:flex;align-items:baseline;gap:0.5rem;flex-wrap:wrap;">
                            <span style="font-size:1.15rem;font-weight:800;color:#60a5fa;letter-spacing:-0.5px;">$${fmtTgt(tgtMean)}</span>
                            ${tgtMed != null && Math.abs(tgtMed - tgtMean) > 0.5 ? `<span style="color:#7e93a6;font-size:0.74rem;">中位 $${fmtTgt(tgtMed)}</span>` : ''}
                            <span style="padding:0.12rem 0.4rem;border-radius:5px;background:${upsideColor}20;
                                color:${upsideColor};font-size:0.82rem;font-weight:700;white-space:nowrap;">
                                ${upside!=null?(parseFloat(upside)>=0?'↑ +':'↓ ')+upside+'%':'—'}
                            </span>
                        </div>
                        <!-- 比較基準標註 -->
                        ${refPrice != null ? `<div style="color:#607585;font-size:0.69rem;margin-top:0.2rem;">
                            vs ${isProxy?sym+' ':''}現價 $${fmtTgt(refPrice)}
                            ${nAna > 0 ? ` · ${nAna} 位分析師` : ''}
                        </div>` : (nAna > 0 ? `<div style="color:#607585;font-size:0.69rem;margin-top:0.2rem;">${nAna} 位分析師</div>` : '')}
                        ${barHtml}
                    </div>`;
                })() : '';

                return `<div style="background:linear-gradient(135deg,rgba(15,30,60,0.65),rgba(10,20,40,0.85));
                    border:1px solid rgba(59,130,246,0.2);border-left:3px solid rgba(56,139,253,0.5);
                    border-radius:12px;padding:1rem 1.25rem;margin-bottom:0.75rem;">
                    <!-- Header -->
                    <div style="display:flex;align-items:center;gap:0.55rem;flex-wrap:wrap;margin-bottom:0.75rem;border-bottom:1px solid rgba(255,255,255,0.07);padding-bottom:0.6rem;">
                        <span style="font-weight:800;color:#f1f5f9;font-size:1rem;">${h.symbol}</span>${proxyLabel}${watchlistLabel}
                        ${recKey ? `<span style="padding:0.18rem 0.6rem;border-radius:6px;background:${recColor}22;color:${recColor};font-weight:700;font-size:0.8rem;">${recLabel}</span>` : ''}
                    </div>
                    <!-- 券商平均目標價 -->
                    ${targetBlock}
                    <!-- 估值指標列 -->
                    ${valuationPills ? `<div style="display:flex;gap:0.35rem;flex-wrap:wrap;margin-bottom:0.75rem;">${valuationPills}</div>` : ''}
                    <div style="display:grid;grid-template-columns:1fr 1fr;gap:1rem;">
                        <!-- 左：財報EPS -->
                        <div>
                            <div style="color:#60a5fa;font-size:0.76rem;font-weight:700;text-transform:uppercase;letter-spacing:0.5px;margin-bottom:0.4rem;"><i class="ic">≡</i> 近4季 EPS</div>
                            ${eh.length > 0 ? `<table style="width:100%;border-collapse:collapse;">
                                <thead><tr style="border-bottom:1px solid rgba(56,139,253,0.15);">
                                    <th style="padding:0.2rem 0.45rem;text-align:left;color:#7e93a6;font-size:0.74rem;font-weight:600;">季度</th>
                                    <th style="padding:0.2rem 0.45rem;text-align:right;color:#7e93a6;font-size:0.74rem;font-weight:600;">預估</th>
                                    <th style="padding:0.2rem 0.45rem;text-align:right;color:#7e93a6;font-size:0.74rem;font-weight:600;">實際</th>
                                    <th style="padding:0.2rem 0.45rem;text-align:right;color:#7e93a6;font-size:0.74rem;font-weight:600;">驚喜</th>
                                </tr></thead>
                                <tbody>${earningsRows}</tbody>
                            </table>` : '<div style="color:#7e93a6;font-size:0.8rem;padding:0.5rem 0;">暫無季度 EPS 歷史（資料更新中）</div>'}
                            ${marginPills ? `<div style="display:flex;gap:0.4rem;flex-wrap:wrap;margin-top:0.5rem;">${marginPills}</div>` : ''}
                            ${epsRow}
                        </div>
                        <!-- 右：近90天分析師動態（新聞形式） -->
                        <div>
                            <div style="color:#60a5fa;font-size:0.76rem;font-weight:700;text-transform:uppercase;letter-spacing:0.5px;margin-bottom:0.4rem;"><i class="ic">◆</i> 近90天分析師動態</div>
                            ${analystNews.length > 0 ? analystNews.map(n => {
                                const dt = new Date((n.providerPublishTime||0)*1000).toLocaleDateString('zh-TW',{month:'2-digit',day:'2-digit'});
                                return `<div onclick="window.open('${n.link||'#'}','_blank','noopener')"
                                    style="margin-bottom:0.45rem;cursor:pointer;padding:0.3rem 0.4rem;border-radius:5px;border-left:2px solid rgba(56,139,253,0.35);background:rgba(255,255,255,0.02);transition:background 0.15s;"
                                    onmouseover="this.style.background='rgba(56,139,253,0.06)'" onmouseout="this.style.background='rgba(255,255,255,0.02)'">
                                    <div style="color:#7e93a6;font-size:0.72rem;margin-bottom:0.1rem;">${dt} · ${n.publisher||''}</div>
                                    <div style="color:#e2e8f0;font-size:0.76rem;line-height:1.35;">${n.titleZh||n.title}</div>
                                    ${n.titleZh&&n.titleZh!==n.title?`<div style="color:#607585;font-size:0.7rem;margin-top:0.1rem;">${n.title}</div>`:''}
                                </div>`;
                            }).join('') : '<div style="color:#7e93a6;font-size:0.8rem;padding:0.5rem 0;">近90天無分析師評級相關新聞</div>'}
                        </div>
                    </div>
                </div>`;
            }).filter(Boolean).join('');

            container.innerHTML = html || '<div style="text-align:center;padding:3rem;color:#7e93a6;">無法取得分析數據</div>';
        }

        // ==================== Tab 5：總體經濟 ====================
        let _macroLoaded = false;
        const MACRO_SYMBOLS = [
            { symbol:'^GSPC',    name:'S&P 500',       cat:'股市' },
            { symbol:'^IXIC',    name:'Nasdaq',         cat:'股市' },
            { symbol:'^SOX',     name:'費城半導體',     cat:'股市' },
            { symbol:'^VIX',     name:'恐慌指數 VIX',   cat:'情緒' },
            { symbol:'^TNX',     name:'10年期美債殖利率',cat:'利率' },
            { symbol:'DX-Y.NYB', name:'美元指數',       cat:'外匯' },
            { symbol:'GC=F',     name:'黃金',           cat:'商品' },
            { symbol:'CL=F',     name:'原油 (WTI)',     cat:'商品' },
            { symbol:'BTC-USD',  name:'Bitcoin',        cat:'加密' },
        ];

        async function loadMacro(forceRefresh) {
            const btn = document.getElementById('macro-btn');
            const statusEl = document.getElementById('macro-status');
            const perfDiv = document.getElementById('macro-perf');
            const newsDiv = document.getElementById('macro-news');

            // ── 快取命中（1小時內）→ 直接渲染，不打 API ──
            if (!forceRefresh) {
                const cached = _loadMacroCache();
                if (cached) {
                    renderMacroTab(cached.results, cached.news);
                    _macroLoaded = true;
                    if (btn) { btn.textContent = '↻ 更新總經數據'; btn.disabled = false; }
                    if (statusEl) {
                        const t = new Date(cached.ts).toLocaleTimeString('zh-TW',{hour:'2-digit',minute:'2-digit'});
                        statusEl.textContent = `快取 ${t}（1hr 後自動更新）`;
                    }
                    return;
                }
                // localStorage 無快取 → 嘗試全域快取
                try {
                    const gc = await _loadGlobalCache();
                    const gcM = gc?.macro;
                    if (gcM && (Date.now() - (gcM.fetched_at || 0)) < _MACRO_CACHE_TTL) {
                        _saveMacroCache(gcM.results, gcM.news);
                        renderMacroTab(gcM.results, gcM.news);
                        _macroLoaded = true;
                        if (btn) { btn.textContent = '↻ 更新總經數據'; btn.disabled = false; }
                        if (statusEl) {
                            const t = new Date(gcM.fetched_at).toLocaleTimeString('zh-TW',{hour:'2-digit',minute:'2-digit'});
                            statusEl.textContent = `全域快取 ${t}（1hr 後自動更新）`;
                        }
                        return;
                    }
                } catch(_) {}
            }

            if (btn) { btn.textContent = '載入中...'; btn.disabled = true; }
            if (perfDiv) perfDiv.innerHTML = '<div style="text-align:center;padding:2rem;color:#7e93a6;">⏳ 抓取總經數據中...</div>';

            const results = [];
            for (let i = 0; i < MACRO_SYMBOLS.length; i++) {
                const m = MACRO_SYMBOLS[i];
                if (statusEl) statusEl.textContent = `(${i+1}/${MACRO_SYMBOLS.length}) ${m.name}...`;
                try {
                    const data = await yfFetch(`https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(m.symbol)}?interval=1d&range=10d`);
                    const ch = data?.chart?.result?.[0];
                    const ts = ch?.timestamp ?? [];
                    const closes = (ch?.indicators?.quote?.[0]?.close ?? []).filter(v => v != null);
                    if (closes.length >= 2) {
                        const cur = closes[closes.length-1];
                        const prev1 = closes[closes.length-2];
                        const sevenAgo = Date.now()/1000 - 7*24*3600;
                        let old7 = closes[0];
                        for (let j = ts.length-1; j >= 0; j--) {
                            if (ts[j] <= sevenAgo && closes[j] != null) { old7 = closes[j]; break; }
                        }
                        results.push({ ...m, price: cur, chg1d:(cur-prev1)/prev1*100, chg7d:(cur-old7)/old7*100 });
                    } else {
                        results.push({ ...m, price:null, chg1d:null, chg7d:null });
                    }
                } catch(e) {
                    results.push({ ...m, price:null, chg1d:null, chg7d:null });
                }
                if (i < MACRO_SYMBOLS.length-1) await new Promise(r => setTimeout(r, 350));
            }

            // ── 抓各持倉標的相關新聞（取代舊的總經新聞）──
            let macroNews = [];
            try {
                if (statusEl) statusEl.textContent = '抓取標的相關新聞...';
                const _newsTargets = _allAnalysisTargets();
                const uniqueSyms = _newsTargets.length > 0
                    ? [...new Set(_newsTargets.map(h => getQuerySymbol(h.symbol)))].slice(0, 6)
                    : [];
                const cutoff = Date.now()/1000 - 7*24*3600;
                const seenUuids = new Set();
                for (let si = 0; si < uniqueSyms.length; si++) {
                    const sym = uniqueSyms[si];
                    try {
                        const nd = await yfFetch(
                            `https://query1.finance.yahoo.com/v1/finance/search?q=${encodeURIComponent(sym)}&newsCount=5&quotesCount=0`
                        ).catch(() => null);
                        const items = (nd?.news||[])
                            .filter(n => (n.providerPublishTime||0) >= cutoff)
                            .filter(n => !seenUuids.has(n.uuid) && seenUuids.add(n.uuid))
                            .map(n => ({...n, _sym: sym}));
                        macroNews.push(...items);
                    } catch(_) {}
                    if (si < uniqueSyms.length - 1) await new Promise(r => setTimeout(r, 250));
                }
                // 若無持倉，降級為總體經濟新聞
                if (macroNews.length === 0) {
                    const nd = await yfFetch('https://query1.finance.yahoo.com/v1/finance/search?q=economy+fed+inflation+rate&newsCount=10&quotesCount=0').catch(() => null);
                    macroNews = (nd?.news||[]).filter(n => (n.providerPublishTime||0) >= cutoff);
                }
                // 依時間排序（最新優先）
                macroNews.sort((a,b) => (b.providerPublishTime||0) - (a.providerPublishTime||0));
                macroNews = macroNews.slice(0, 20); // 最多20則
            } catch(e) {}

            // 翻譯新聞標題為繁體中文（使用 MyMemory 免費 API，並以 localStorage 快取24hr避免重複翻譯）
            if (macroNews.length > 0) {
                try {
                    if (statusEl) statusEl.textContent = '翻譯新聞標題...';
                    const _tCacheKey = 'pf_news_trans_v1';
                    let tCache = {};
                    try {
                        const raw = JSON.parse(localStorage.getItem(_tCacheKey)||'{}');
                        tCache = (Date.now() - (raw.ts||0) < 24*3600*1000) ? (raw.data||{}) : {};
                    } catch(_) {}
                    let tUpdated = false;
                    for (const item of macroNews) {
                        const orig = item.title || '';
                        if (!orig) { item.titleZh = orig; continue; }
                        if (tCache[orig]) { item.titleZh = tCache[orig]; continue; }
                        try {
                            const r = await fetch(
                                `https://api.mymemory.translated.net/get?q=${encodeURIComponent(orig)}&langpair=en|zh-TW`,
                                { signal: AbortSignal.timeout(6000) }
                            );
                            if (r.ok) {
                                const d = await r.json();
                                const zh = d?.responseData?.translatedText || orig;
                                item.titleZh = zh;
                                tCache[orig] = zh;
                                tUpdated = true;
                            } else {
                                item.titleZh = orig;
                            }
                        } catch(_) { item.titleZh = orig; }
                        await new Promise(r => setTimeout(r, 300)); // 避免 rate limit
                    }
                    if (tUpdated) {
                        const _te = Object.entries(tCache);
                        if (_te.length > 200) tCache = Object.fromEntries(_te.slice(-200));
                        try { localStorage.setItem(_tCacheKey, JSON.stringify({ts:Date.now(), data:tCache})); } catch(_) {}
                    }
                } catch(_) {}
            }

            // 存入本地快取（1小時 TTL）
            _saveMacroCache(results, macroNews);

            // 回寫全域快取
            try {
                const gc = await _loadGlobalCache();
                gc.macro = { results, news: macroNews, fetched_at: Date.now() };
                _globalCacheDirty = true;
                _pushGlobalCache();
            } catch(_) {}

            renderMacroTab(results, macroNews);
            _macroLoaded = true;
            if (btn) { btn.textContent = '↻ 更新總經數據'; btn.disabled = false; }
            if (statusEl) statusEl.textContent = '更新於 ' + new Date().toLocaleTimeString('zh-TW');
        }

        function renderMacroTab(data, news) {
            const perfDiv = document.getElementById('macro-perf');
            const newsDiv = document.getElementById('macro-news');

            if (perfDiv) {
                const cats = [...new Set(data.map(d => d.cat))];
                const pctCell = (v, label) => {
                    if (v == null) return `<span style="color:#7e93a6;font-size:0.76rem;">${label}:-</span>`;
                    const pos = v >= 0;
                    const col = pos ? '#10b981' : '#ef4444';
                    const bg  = pos ? 'rgba(16,185,129,0.1)' : 'rgba(239,68,68,0.1)';
                    return `<span style="padding:0.1rem 0.4rem;border-radius:4px;background:${bg};color:${col};font-size:0.76rem;">${label}:${pos?'+':''}${v.toFixed(2)}%</span>`;
                };
                perfDiv.innerHTML = cats.map(cat => {
                    const items = data.filter(d => d.cat === cat);
                    return `<div style="margin-bottom:1.25rem;">
                        <div style="color:#60a5fa;font-size:0.8rem;font-weight:700;text-transform:uppercase;letter-spacing:1px;margin-bottom:0.5rem;">${cat}</div>
                        <div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(180px,1fr));gap:0.5rem;">
                        ${items.map(item => `
                            <div class="macro-card">
                                <div style="color:#a8bdd0;font-size:0.75rem;margin-bottom:0.2rem;">${item.name}</div>
                                <div style="color:#f1f5f9;font-size:1.1rem;font-weight:700;margin-bottom:0.3rem;">${item.price != null ? item.price.toFixed(2) : '-'}</div>
                                <div style="display:flex;gap:0.35rem;flex-wrap:wrap;">${pctCell(item.chg1d,'今日')}${pctCell(item.chg7d,'7天')}</div>
                            </div>`).join('')}
                        </div>
                    </div>`;
                }).join('') + generateMacroAnalysis(data);
            }

            if (newsDiv) {
                if (news.length === 0) {
                    newsDiv.innerHTML = '<div style="color:#7e93a6;text-align:center;padding:1.5rem;">暫無最新標的相關新聞</div>';
                } else {
                    newsDiv.innerHTML = news.map(item => {
                        const dt = new Date(item.providerPublishTime*1000);
                        const dtStr = dt.toLocaleDateString('zh-TW',{month:'2-digit',day:'2-digit'}) + ' ' +
                                      dt.toLocaleTimeString('zh-TW',{hour:'2-digit',minute:'2-digit'});
                        return `<div onclick="window.open('${item.link}','_blank','noopener')"
                            style="background:rgba(15,30,60,0.5);border:1px solid rgba(59,130,246,0.15);
                                   border-radius:8px;padding:0.6rem 0.85rem;margin-bottom:0.4rem;cursor:pointer;transition:all 0.2s;"
                            onmouseover="this.style.borderColor='rgba(59,130,246,0.4)'"
                            onmouseout="this.style.borderColor='rgba(59,130,246,0.15)'">
                            <div style="color:#7e93a6;font-size:0.74rem;margin-bottom:0.2rem;">
                                ${item._sym ? `<span style="background:rgba(56,139,253,0.15);color:#60a5fa;border-radius:3px;padding:0.05rem 0.3rem;font-size:0.7rem;font-weight:700;margin-right:0.3rem;">${item._sym}</span>` : ''}${item.publisher||''} · ${dtStr}
                            </div>
                            <div style="color:#e2e8f0;font-size:0.85rem;">${item.titleZh || item.title}</div>
                            ${item.titleZh && item.titleZh !== item.title ? `<div style="color:#607585;font-size:0.73rem;margin-top:0.15rem;">${item.title}</div>` : ''}
                        </div>`;
                    }).join('');
                }
            }
        }

        function generateMacroAnalysis(data) {
            const get = sym => data.find(d => d.symbol === sym);
            const sp500 = get('^GSPC'), vix = get('^VIX'), tnx = get('^TNX'),
                  dxy   = get('DX-Y.NYB'), sox = get('^SOX');
            const signals = [];

            if (sp500?.chg7d != null) {
                if (sp500.chg7d > 3)       signals.push({ t:'positive', msg:`S&P500 近7天上漲 <b>+${sp500.chg7d.toFixed(1)}%</b>，市場整體偏多，風險偏好上升。` });
                else if (sp500.chg7d < -3) signals.push({ t:'negative', msg:`S&P500 近7天下跌 <b>${sp500.chg7d.toFixed(1)}%</b>，市場情緒偏空，注意回撤風險。` });
                else                       signals.push({ t:'neutral',  msg:`S&P500 近7天小幅波動 <b>${sp500.chg7d>=0?'+':''}${sp500.chg7d.toFixed(1)}%</b>，方向尚未明確。` });
            }
            if (vix?.price != null) {
                if (vix.price > 30)      signals.push({ t:'negative', msg:`VIX 恐慌指數 <b>${vix.price.toFixed(1)}</b> 偏高，市場波動劇烈，建議降低槓桿部位。` });
                else if (vix.price < 15) signals.push({ t:'positive', msg:`VIX 恐慌指數 <b>${vix.price.toFixed(1)}</b> 偏低，市場情緒平穩。` });
                else                     signals.push({ t:'neutral',  msg:`VIX 恐慌指數 <b>${vix.price.toFixed(1)}</b> 處於中性區間（15-30）。` });
            }
            if (tnx?.price != null) {
                if (tnx.price > 4.5)      signals.push({ t:'negative', msg:`10年期美債殖利率 <b>${tnx.price.toFixed(2)}%</b> 偏高，對成長股估值形成壓力。` });
                else if (tnx.price < 4.0) signals.push({ t:'positive', msg:`10年期美債殖利率 <b>${tnx.price.toFixed(2)}%</b>，利率壓力相對緩解，有利成長股。` });
            }
            if (dxy?.chg7d != null) {
                if (dxy.chg7d > 1)       signals.push({ t:'negative', msg:`美元指數近7天升值 <b>+${dxy.chg7d.toFixed(1)}%</b>，對新興市場及商品有壓制效果。` });
                else if (dxy.chg7d < -1) signals.push({ t:'positive', msg:`美元指數近7天貶值 <b>${dxy.chg7d.toFixed(1)}%</b>，有利商品及非美資產。` });
            }
            if (sox?.chg7d != null) {
                if (sox.chg7d > 4)       signals.push({ t:'positive', msg:`費城半導體指數近7天上漲 <b>+${sox.chg7d.toFixed(1)}%</b>，科技板塊強勢，持有半導體相關標的可留意。` });
                else if (sox.chg7d < -4) signals.push({ t:'negative', msg:`費城半導體指數近7天下跌 <b>${sox.chg7d.toFixed(1)}%</b>，科技板塊走弱，留意相關持倉。` });
            }

            if (signals.length === 0) return '';
            return `<div style="background:rgba(15,30,60,0.5);border:1px solid rgba(56,139,253,0.25);border-radius:12px;padding:1rem 1.1rem;margin-top:0.75rem;">
                <div style="color:#60a5fa;font-size:0.85rem;font-weight:700;margin-bottom:0.65rem;"><i class="ic">◈</i> 總體環境分析摘要</div>
                ${signals.map(s=>`<div style="display:flex;align-items:flex-start;gap:0.5rem;margin-bottom:0.45rem;">
                    <span style="flex-shrink:0;">${s.t==='positive'?'✅':s.t==='negative'?'⚠️':'ℹ️'}</span>
                    <span style="color:${s.t==='positive'?'#6ee7b7':s.t==='negative'?'#fca5a5':'#94a3b8'};font-size:0.85rem;line-height:1.55;">${s.msg}</span>
                </div>`).join('')}
            </div>`;
        }

        async function silentRefreshPrices() {
            const sheetUrl = (document.getElementById('sheet-url')?.value || '').trim();
            if (!sheetUrl || !sheetUrl.includes('docs.google.com')) return;
            try {
                // 匯率：快取 1hr 內不打 API（按需更新策略）
                const fxPromise = _fetchFxRates(false);
                const controller  = new AbortController();
                const tid = setTimeout(() => controller.abort(), 25000);
                const res = await _fetchSheetCSV(sheetUrl, controller.signal);
                clearTimeout(tid);
                if (!res) return;
                const csvText = await res.text();
                if (csvText.trim().startsWith('<')) return;

                const prices = {}, sheetRates = {};
                csvText.trim().split(/\r?\n/).forEach(line => {
                    const cols = line.trim().split(',').map(c => c.replace(/"/g,'').trim());
                    const val  = parseFloat(cols[1]);
                    if (!cols[0] || isNaN(val) || val <= 0) return;
                    if      (cols[0] === 'USD_TWD') sheetRates.USD_TWD = val;
                    else if (cols[0] === 'HKD_TWD') sheetRates.HKD_TWD = val;
                    else prices[cols[0]] = val;
                });

                // 更新匯率（Sheet 指定 > 快取/即時 API）
                const fx = await fxPromise;
                if (sheetRates.USD_TWD) exchangeRates.USD_TWD = sheetRates.USD_TWD;
                if (sheetRates.HKD_TWD) exchangeRates.HKD_TWD = sheetRates.HKD_TWD;
                if (!sheetRates.USD_TWD && fx) {
                    exchangeRates.USD_TWD = fx.USD_TWD;
                    exchangeRates.HKD_TWD = fx.HKD_TWD;
                }
                syncRateInputs();

                // 靜默更新股價（不存入 undo 歷史）
                let updated = 0;
                const updatedMarkets = new Set();   // v15.072：只標實際被刷到的市場
                holdings.forEach(h => {
                    const np = _lookupPrice(prices, h);
                    if (np != null && !isNaN(np) && np > 0) {
                        h.currentPrice = parseFloat(np);
                        updated++;
                        const mk = _holdingMarketKey(h);
                        if (mk === 'TW' || mk === 'HK' || mk === 'US') updatedMarkets.add(mk);
                    }
                });
                if (updated > 0 || Object.keys(sheetRates).length > 0) {
                    // v15.072：CSV 不一定覆蓋三市場，只給有實際刷到報價的市場 mark lastQuoteAt
                    if (updatedMarkets.size > 0) {
                        try { _markBatchQuoteRefresh([...updatedMarkets], 'csv-silent'); } catch(_) {}
                    }
                    // v15.080 後續修補：報價更新後若 _prevCloseCache 缺失，背景排 loadAnalysis 補正
                    try {
                        const _missingBaseline = holdings.some(h => {
                            const pc = window._prevCloseCache?.[h.symbol];
                            return pc == null || !(pc > 0);
                        });
                        if (_missingBaseline && typeof loadAnalysis === 'function') {
                            clearTimeout(window._missingBaselineTimer);
                            window._missingBaselineTimer = setTimeout(() => loadAnalysis(false, true), 1500);
                        }
                    } catch(_) {}
                    renderAll();
                    recordSnapshot(); // 自動報價更新後記錄快照（同月已有則略過）
                    const now = new Date().toLocaleTimeString('zh-TW');
                    const el = document.getElementById('auto-refresh-time');
                    if (el) el.textContent = now;
                    const rateEl = document.getElementById('rate-source');
                    if (rateEl) rateEl.textContent = `✓ 自動更新（${now}）`;
                }
            } catch(e) { /* 靜默失敗 */ }
        }

        // ── 字體大小調整 ──
        (function(){
            const saved = parseInt(localStorage.getItem('font_size')||'16',10);
            document.documentElement.style.fontSize = saved + 'px';
            const lbl = document.getElementById('font-size-label');
            if(lbl) lbl.textContent = saved + 'px';
        })();
        function adjustFontSize(delta){
            const html = document.documentElement;
            const cur  = parseInt(html.style.fontSize||'16',10);
            const next = Math.max(11, Math.min(24, cur + delta));
            html.style.fontSize = next + 'px';
            localStorage.setItem('font_size', next);
            const lbl = document.getElementById('font-size-label');
            if(lbl) lbl.textContent = next + 'px';
        }
    </script>

    <!-- v15.079：手動推送三選一 modal -->
    <div id="push-mode-modal" style="display:none; position:fixed; inset:0; z-index:9000; background:rgba(0,0,0,0.65); align-items:center; justify-content:center; padding:1rem;">
        <div class="glass-card" style="max-width:440px; width:100%; padding:1.5rem; max-height:90vh; overflow-y:auto;">
            <h3 style="margin:0 0 0.5rem 0; color:#e2e8f0;">推送至雲端</h3>
            <p style="color:#94a3b8; font-size:0.88rem; margin:0 0 1rem 0;">你要如何推送這次資料？</p>
            <button id="pm-master" style="display:block; width:100%; margin:0 0 0.6rem 0; padding:0.85rem 1rem; text-align:left; background:linear-gradient(135deg, rgba(59,130,246,0.25), rgba(37,99,235,0.18)); border:1.5px solid rgba(96,165,250,0.45); color:#e2e8f0; text-transform:none; letter-spacing:0;">
                <div style="font-weight:700; font-size:0.95rem;">標記最新版</div>
                <div style="font-size:0.78rem; opacity:0.78; margin-top:0.18rem;">把目前本機資料視為主版本；其他裝置會自動拉取這份。也會在本機建立回復點。</div>
            </button>
            <button id="pm-staging" style="display:block; width:100%; margin:0 0 0.6rem 0; padding:0.85rem 1rem; text-align:left; background:linear-gradient(135deg, rgba(148,163,184,0.18), rgba(100,116,139,0.12)); border:1.5px solid rgba(148,163,184,0.4); color:#e2e8f0; text-transform:none; letter-spacing:0;">
                <div style="font-weight:700; font-size:0.95rem;">暫存上傳</div>
                <div style="font-size:0.78rem; opacity:0.78; margin-top:0.18rem;">只把目前資料備份到 Gist；其他裝置不會被強制覆蓋。</div>
            </button>
            <button id="pm-cancel" style="display:block; width:100%; margin:0; padding:0.7rem 1rem; text-align:center; background:transparent; border:1px solid rgba(148,163,184,0.3); color:#94a3b8; text-transform:none; letter-spacing:0;">
                取消
            </button>
        </div>
    </div>

</body>
</html>