honeydo 0.1.3 → 0.2.0

package/packages/gcli/dist/cli.js

@@ -227,7 +227,7 @@ export function buildSettingsEnv(providerEnv, model) {
  * - "return" / "enter" → confirm the current row (the physical Enter key
  *   emits "return" in raw mode; "enter" is the LF byte, which a tty may
  *   substitute for CR in input buffered before raw mode was enabled)
- * - "escape"     → skip (不切换)
+ * - "escape"     → skip (退出，不启动后端)
  * - Emacs (revise-2): ctrl+"n" ≡ down, ctrl+"p" ≡ up (same wrap); ctrl+"g"
  *   ≡ escape → skip; meta+"<" → first row (absolute), meta+">" → last row
  *   (absolute). Horizontal Emacs keys (C-f/C-b/C-a/C-e) and paging (C-v/M-v)
@@ -236,7 +236,7 @@ export function buildSettingsEnv(providerEnv, model) {
  *   exit 130)
  *
  * `index` is the highlighted row, `count` the total rendered rows INCLUDING
- * the trailing 不切换 row. Movement wraps with `(index±1+count)%count`; with
+ * the footer row. Movement wraps with `(index±1+count)%count`; with
  * count <= 0 moves are a noop (nothing is rendered).
  */
 export function applyPickerKey(k, index, count) {
@@ -396,7 +396,9 @@ export function parseKimiUsages(body) {
 }
 /**
  * Parse GLM `/api/monitor/usage/quota/limit` (C-Q2): data.limits[] entries
- * with type == "TOKENS_LIMIT"; sorted by nextResetTime ascending — first is
+ * with type "TOKENS_LIMIT" (coding-plan 订阅) or "CREDIT_LIMIT" (credit 资源
+ * 包) — billing type is per-account, fields are identical, same rendering
+ * (parity with statusline-sage); sorted by nextResetTime ascending — first is
  * the short (5h) window, last the weekly one.
  */
 export function parseGlmQuota(body) {
@@ -413,7 +415,7 @@ export function parseGlmQuota(body) {
         if (typeof item !== "object" || item === null)
             continue;
         const r = item;
-        if (r.type !== "TOKENS_LIMIT")
+        if (r.type !== "TOKENS_LIMIT" && r.type !== "CREDIT_LIMIT")
             continue;
         const pct = toNum(r.percentage);
         if (pct === undefined)
@@ -451,20 +453,90 @@ function formatReset(iso, nowMs) {
     return rh > 0 ? `${d}d${rh}h` : `${d}d`;
 }
 /**
- * Format quota windows as the menu subtitle (C-Q3): `5h:P% wk:P% ↻<rel>`
- * (short reset preferred for the ↻ segment); missing windows degrade; a
- * missing/expired reset omits the ↻ segment entirely; no windows → "".
+ * Structured render input shared by the plain and the colored quota
+ * renderers: one percentage + one relative reset per window (each window's
+ * reset computed independently; missing/expired → omitted for that window).
+ * No windows at all → empty parts (the plain join then yields "").
+ */
+function quotaParts(q, nowMs) {
+    const shortPct = q.short?.pct;
+    const weeklyPct = q.weekly?.pct;
+    if (shortPct === undefined && weeklyPct === undefined)
+        return {};
+    return {
+        shortPct,
+        weeklyPct,
+        shortResetRel: q.short === undefined ? undefined : formatReset(q.short.resetIso, nowMs),
+        weeklyResetRel: q.weekly === undefined
+            ? undefined
+            : formatReset(q.weekly.resetIso, nowMs),
+    };
+}
+/**
+ * Format quota windows as the menu subtitle (C-Q3, 2026-09 双窗重置):
+ * `5h:P% ↻<rel> wk:P% ↻<rel>` — each window carries its own reset time.
+ * Missing windows degrade; a missing/expired reset omits that window's ↻;
+ * no windows → "". Byte-exact contract with downstream consumers — the
+ * plain-text output is locked by unit tests; colors live in `colorQuota`,
+ * never here.
  */
 export function formatQuota(q, nowMs) {
+    const p = quotaParts(q, nowMs);
     const parts = [];
-    if (q.short !== undefined)
-        parts.push(`5h:${q.short.pct}%`);
-    if (q.weekly !== undefined)
-        parts.push(`wk:${q.weekly.pct}%`);
-    if (parts.length === 0)
-        return "";
-    const rel = formatReset(q.short?.resetIso ?? q.weekly?.resetIso, nowMs);
-    return rel === undefined ? parts.join(" ") : `${parts.join(" ")} ↻${rel}`;
+    if (p.shortPct !== undefined) {
+        parts.push(p.shortResetRel === undefined
+            ? `5h:${p.shortPct}%`
+            : `5h:${p.shortPct}% ↻${p.shortResetRel}`);
+    }
+    if (p.weeklyPct !== undefined) {
+        parts.push(p.weeklyResetRel === undefined
+            ? `wk:${p.weeklyPct}%`
+            : `wk:${p.weeklyPct}% ↻${p.weeklyResetRel}`);
+    }
+    return parts.join(" ");
+}
+// Limit 染色阈值（对齐 statusline-sage 的 GLM_HIGH/GLM_MID）。
+export const QUOTA_HIGH = 85;
+export const QUOTA_MID = 60;
+/** truecolor Sage 同款三色：#3A7D68 苔绿 / #D4920A 琥珀 / #D94F3D 朱红。 */
+const COLOR_SAGE = "\x1b[38;2;58;125;104m";
+const COLOR_AMBER = "\x1b[38;2;212;146;10m";
+const COLOR_VERMILION = "\x1b[38;2;217;79;61m";
+/** 关闭前景色回到终端默认，但不复位背景——选中行的整行高亮依赖这一点。 */
+const FG_OFF = "\x1b[39m";
+/**
+ * Limit 用量 → 段颜色：≥85 朱红、≥60 琥珀、其余（含非有限数）回退苔绿
+ * （阈值语义照搬 statusline-sage `_level_color`）。
+ */
+export function levelColor(pct) {
+    if (!Number.isFinite(pct))
+        return COLOR_SAGE;
+    if (pct >= QUOTA_HIGH)
+        return COLOR_VERMILION;
+    if (pct >= QUOTA_MID)
+        return COLOR_AMBER;
+    return COLOR_SAGE;
+}
+/**
+ * `formatQuota` 的染色版（picker 用）：`5h:P% ↻rel`/`wk:P% ↻rel` 每个窗口段
+ * 按各自 pct 独立选色，各自的重置时间恒 dim，不参与染色。结构与降级规则和
+ * `formatQuota` 一致（无窗口 → ""）。行内使用 `\x1b[39m`/`\x1b[22m` 收尾而
+ * 非全复位，以免抹掉选中行背景。
+ */
+export function colorQuota(q, nowMs) {
+    const p = quotaParts(q, nowMs);
+    const parts = [];
+    if (p.shortPct !== undefined) {
+        parts.push(p.shortResetRel === undefined
+            ? `${levelColor(p.shortPct)}5h:${p.shortPct}%${FG_OFF}`
+            : `${levelColor(p.shortPct)}5h:${p.shortPct}%${FG_OFF} \x1b[2m↻${p.shortResetRel}\x1b[22m`);
+    }
+    if (p.weeklyPct !== undefined) {
+        parts.push(p.weeklyResetRel === undefined
+            ? `${levelColor(p.weeklyPct)}wk:${p.weeklyPct}%${FG_OFF}`
+            : `${levelColor(p.weeklyPct)}wk:${p.weeklyPct}%${FG_OFF} \x1b[2m↻${p.weeklyResetRel}\x1b[22m`);
+    }
+    return parts.join(" ");
 }
 /**
  * Build claude argv (C8). `--model` is NOT passed here — for the claude
@@ -1405,12 +1477,20 @@ export function runClaude(args, timeoutMs, cwd) {
  * Unlike runAgy/runClaude: no timeout, no stdout/stderr capture —
  * the child owns the terminal. The child's exit code is passed
  * through unchanged (SIGINT→130, SIGTERM→143 per shell convention).
+ *
+ * An inherited CLAUDE_CODE_CHILD_SESSION=1 is stripped: claude reads it as
+ * "spawned sub-worker" and silently turns transcript saving off, so the
+ * session never shows up in `claude --resume`. An attended TUI is a
+ * top-level session, never a sub-worker. agy never reads the var, so the
+ * strip is a no-op there; print mode keeps the env verbatim.
  */
-function spawnInteractive(bin, args, cwd) {
+export function spawnInteractive(bin, args, cwd) {
+    const env = { ...process.env };
+    delete env.CLAUDE_CODE_CHILD_SESSION;
     return new Promise((resolveFn) => {
         const child = spawn(bin, args, {
             cwd,
-            env: { ...process.env },
+            env,
             stdio: "inherit",
         });
         child.on("error", (err) => {
@@ -1870,17 +1950,122 @@ function readStdin() {
 // ---------------------------------------------------------------------------
 // Provider picker (TTY only) — arrow keys, zero deps
 // ---------------------------------------------------------------------------
+// Picker frame colors: 16-color structure + truecolor Sage accents (B2).
+const DIM_ON = "\x1b[2m";
+const INTENSITY_OFF = "\x1b[22m";
+const CYAN = "\x1b[36m";
+const BOLD_ON = "\x1b[1m";
+const RESET_ALL = "\x1b[0m";
+/** 选中行背景 #292e42（truecolor）。 */
+const SELECTED_BG = "\x1b[48;2;41;46;66m";
+const PICKER_TITLE_MAIN = "◆ gcli";
+const PICKER_TITLE_SUB = " · 选择 provider";
+const PICKER_HINT_KEYS = "↑↓/j/k 移动 · Enter 确认 · Esc 不切换";
+const PICKER_HINT_SKIP = "Esc 不切换";
+const PICKER_SEPARATOR = "─".repeat(50);
+const NO_QUOTA_MARK = "—";
+/**
+ * 给 picker 实际持有的 quota 文本（`formatQuota` 输出格式，byte-locked）上
+ * 色：`5h:P%`/`wk:P%` token 按各自 pct 染色，`↻rel` token 恒 dim。与
+ * `colorQuota` 同一视觉，只是入参是已格式化文本（DI 契约里 entries.quota
+ * 为 string，渲染层拿不到结构化窗口）。前提：pct 为整数——生产 parsers
+ * 均 Math.floor 保证；异形 token 优雅退化为不染色。
+ */
+function colorQuotaText(text) {
+    return text
+        .split(" ")
+        .map((token) => {
+        const win = /^(5h|wk):(\d+)%$/.exec(token);
+        if (win !== null) {
+            return `${levelColor(Number(win[2]))}${token}${FG_OFF}`;
+        }
+        if (token.startsWith("↻"))
+            return `${DIM_ON}${token}${INTENSITY_OFF}`;
+        return token;
+    })
+        .join(" ");
+}
+/**
+ * One entry row: `❯ `/two-space prefix | name column (max name width + 2,
+ * left-aligned) | colored quota (or dim — placeholder) padded to the widest
+ * quota across entries | dim ` <n>会话` (only when entry.sessions is set) |
+ * cyan `●<tag>`. The quota pad (by JS `.length`) keeps the session column
+ * start aligned across rows; padding sits outside the colored segments so
+ * the dim placeholder stays contiguous. Selected rows add the truecolor
+ * background + a bold name and end with a full reset; unselected rows keep
+ * the same structure without background.
+ */
+function pickerEntryRow(entry, selected, nameWidth, quotaWidth, noColor) {
+    const name = entry.name.padEnd(nameWidth);
+    const quotaText = entry.quota !== undefined && entry.quota !== "" ? entry.quota : undefined;
+    const pad = " ".repeat(Math.max(0, quotaWidth - (quotaText ?? NO_QUOTA_MARK).length));
+    const quota = quotaText === undefined
+        ? noColor
+            ? NO_QUOTA_MARK
+            : `${DIM_ON}${NO_QUOTA_MARK}${INTENSITY_OFF}`
+        : noColor
+            ? quotaText
+            : colorQuotaText(quotaText);
+    const quotaColumn = `${quota}${pad}`;
+    const sessions = entry.sessions === undefined
+        ? ""
+        : noColor
+            ? ` ${entry.sessions}会话`
+            : `${DIM_ON} ${entry.sessions}会话${INTENSITY_OFF}`;
+    const tag = entry.tag !== undefined && entry.tag !== ""
+        ? noColor
+            ? ` ●${entry.tag}`
+            : ` ${CYAN}●${entry.tag}${FG_OFF}`
+        : "";
+    if (noColor) {
+        return `${selected ? "❯ " : "  "}${name}${quotaColumn}${sessions}${tag}`;
+    }
+    return selected
+        ? `${SELECTED_BG}${COLOR_SAGE}❯${FG_OFF} ${BOLD_ON}${name}${INTENSITY_OFF}${quotaColumn}${sessions}${tag}${RESET_ALL}`
+        : `  ${name}${quotaColumn}${sessions}${tag}`;
+}
+/**
+ * The full picker frame as plain lines: 标题 2 行 + dim 分隔线 + 条目 N 行 +
+ * dim 末行提示 (non-selectable — skip 只经 Esc/C-g). With `unattributedCount >
+ * 0` the footer reads `另有 N 个裸 claude 会话未归属 · Esc 不切换` (bare claude
+ * processes carry no --settings and cannot be attributed to a provider);
+ * otherwise it is plain `Esc 不切换`. Pure: no I/O; with `noColor` (NO_COLOR
+ * downgrade) zero ANSI escapes — 仅纯文本排版，❯ 缩进 + 列对齐保留。Redraw
+ * cursor-up height = `entries.length + 4` regardless (footer merges into the
+ * one hint row).
+ */
+export function renderPickerRows(entries, selectedIndex, noColor, unattributedCount = 0) {
+    const nameWidth = entries.reduce((w, e) => Math.max(w, e.name.length), 0) + 2;
+    const quotaWidth = entries.reduce((w, e) => Math.max(w, (e.quota !== undefined && e.quota !== "" ? e.quota : NO_QUOTA_MARK)
+        .length), 0);
+    const rows = [
+        noColor
+            ? `${PICKER_TITLE_MAIN}${PICKER_TITLE_SUB}`
+            : `${CYAN}${BOLD_ON}${PICKER_TITLE_MAIN}${RESET_ALL}${PICKER_TITLE_SUB}`,
+        noColor ? PICKER_HINT_KEYS : `${DIM_ON}${PICKER_HINT_KEYS}${INTENSITY_OFF}`,
+        noColor ? PICKER_SEPARATOR : `${DIM_ON}${PICKER_SEPARATOR}${INTENSITY_OFF}`,
+    ];
+    for (let i = 0; i < entries.length; i++) {
+        rows.push(pickerEntryRow(entries[i], i === selectedIndex, nameWidth, quotaWidth, noColor));
+    }
+    const footerText = unattributedCount > 0
+        ? `另有 ${unattributedCount} 个裸 claude 会话未归属 · ${PICKER_HINT_SKIP}`
+        : PICKER_HINT_SKIP;
+    rows.push(noColor ? footerText : `${DIM_ON}${footerText}${INTENSITY_OFF}`);
+    return rows;
+}
 /**
  * Production deps.pickProvider: arrow-key menu rendered entirely on stderr
  * (stdout stays pipe-clean). ↑↓/j/k move with wrap, Enter confirms, Esc
  * skips, ctrl-c restores the terminal then exits 130; any other key is a
- * noop (C-P1).
+ * noop (C-P1). Frame = 标题 2 行 + 分隔线 + 条目 N 行 + dim `Esc 不切换`
+ * 末行提示——旧的可选中「不切换」行已退化为提示（skip 走 Esc/C-g），移动
+ * 只覆盖条目行。
  *
  * Zero deps: `readline.emitKeypressEvents` + raw-mode stdin + hand-written
- * ANSI. Rows are redrawn in place (cursor-up + `\r` + clear-to-EOL per line)
- * so navigation leaves no ghosting (C-P3). The trailing 不切换 row is
- * appended here — `entries` holds providers only (D4); confirming it (or
- * pressing Esc) resolves {kind:"skip"}.
+ * ANSI (16-color structure + truecolor Sage Limit 染色; `NO_COLOR` 非空 →
+ * 全无色纯文本). Rows are redrawn in place (cursor-up + `\r` + clear-to-EOL
+ * per line) so navigation leaves no ghosting (C-P3).
  *
  * Raw-mode lifecycle: `process.stdin.isRaw` is saved before
  * `setRawMode(true)` and restored on EVERY exit path (confirm / Esc / ctrl-c
@@ -1888,51 +2073,74 @@ function readStdin() {
  * its lazily-attached internal `data`) listeners are removed — so the
  * spawned claude TUI takes stdin over cleanly. The picker always completes
  * before any backend spawn.
+ *
+ * `unattributedCount` (optional) drives the bare-claude footer hint; 0 or
+ * omitted renders the plain `Esc 不切换` footer. When the positional arg is
+ * absent, the count is recovered from the entries themselves
+ * (`PickerEntry.unattributed`, attached by the claude menu path) so two-arg
+ * pickProvider wrappers still render the hint.
  */
-function pickProviderInteractive(entries, initialIndex) {
+export function pickProviderInteractive(entries, initialIndex, unattributedCount) {
     return new Promise((resolvePromise) => {
         const stderr = process.stderr;
         const stdin = process.stdin;
-        const rowCount = entries.length + 1; // D1: count includes the 不切换 row
-        let index = Math.min(Math.max(Math.trunc(initialIndex), 0), rowCount - 1); // clamp (D4)
+        const noColor = (process.env.NO_COLOR ?? "") !== "";
+        const frameUnattributed = unattributedCount ??
+            entries.find((e) => e.unattributed !== undefined)?.unattributed ??
+            0;
+        const frameRows = entries.length + 4; // 标题2 + 分隔线1 + 条目N + 末行1
+        let index = Math.min(Math.max(Math.trunc(initialIndex), 0), Math.max(entries.length - 1, 0)); // clamp (D4)
         let settled = false;
-        const SKIP_LABEL = "不切换（使用 cc-switch 当前生效配置）";
-        const TITLE = "gcli: 选择 cc-switch provider（↑↓/j/k/C-n/C-p 移动 · Enter 确认 · Esc/C-g 不切换）:";
-        const labelOf = (row) => {
-            if (row >= entries.length)
-                return SKIP_LABEL;
-            const entry = entries[row];
-            return entry.quota ? `${entry.name}  ${entry.quota}` : entry.name;
-        };
-        // Selected row: ❯ + full-line inverse video; unselected: two-space indent
-        // (C-P7). \x1b[K clears to EOL so a shorter previous render leaves no
-        // ghosting (残影).
-        const rowText = (row) => {
-            const label = labelOf(row);
-            return row === index
-                ? `\x1b[7m❯ ${label}\x1b[27m\x1b[K`
-                : `  ${label}\x1b[K`;
-        };
-        const drawRows = () => {
-            for (let row = 0; row < rowCount; row++) {
-                stderr.write(`${rowText(row)}\n`);
+        // Full repaint: pure row construction + per-line clear-to-EOL so a
+        // shorter previous render leaves no ghosting (残影).
+        const drawFrame = () => {
+            for (const line of renderPickerRows(entries, index, noColor, frameUnattributed)) {
+                stderr.write(`${line}\x1b[K\n`);
             }
         };
         // In-place redraw: the cursor sits just below the last row after each
-        // draw, so move it back up over every entry row before repainting.
+        // draw, so move it back up over every frame line before repainting.
         const redraw = () => {
-            stderr.write(`\x1b[${rowCount}A\r`);
-            drawRows();
+            stderr.write(`\x1b[${frameRows}A\r`);
+            drawFrame();
         };
         // Raw-mode lifecycle (C-P3): save → raw → ... EVERY exit path restores.
         const wasRaw = stdin.isRaw === true;
         const dataListenersBefore = stdin.listeners("data");
         let onKeypress;
         let onGone = () => { };
+        // 孤立 ESC 快速路径：emitKeypressEvents 不带 interface 参数时没有 escape
+        // 消歧超时，真实终端按 Esc 发出的孤立 \x1b 会被状态机无限挂起（keypress
+        // 永不发出）——实测 PTY 下 30s 无事件。因此监听 data 层：单字节 \x1b 且
+        // 50ms 内无后续字节 → 视为 Esc 键 skip；有后续（箭头序列拆包等）→ 取消
+        // 计时器交还 readline 正常解析。readline 的 name==="escape" 路径保留，
+        // settled 守卫防双触发。
+        let escTimer;
+        const onDataFastEsc = (chunk) => {
+            const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            if (s !== "\x1b") {
+                if (escTimer !== undefined) {
+                    clearTimeout(escTimer);
+                    escTimer = undefined;
+                }
+                return;
+            }
+            if (escTimer !== undefined)
+                clearTimeout(escTimer);
+            escTimer = setTimeout(() => {
+                escTimer = undefined;
+                finish({ kind: "skip" });
+            }, 50);
+        };
         const cleanup = () => {
             if (onKeypress !== undefined) {
                 stdin.removeListener("keypress", onKeypress);
             }
+            if (escTimer !== undefined) {
+                clearTimeout(escTimer);
+                escTimer = undefined;
+            }
+            stdin.removeListener("data", onDataFastEsc);
             stdin.removeListener("close", onGone);
             stdin.removeListener("error", onGone);
             // emitKeypressEvents lazily attaches an internal 'data' listener (via
@@ -1955,9 +2163,8 @@ function pickProviderInteractive(entries, initialIndex) {
             cleanup();
             resolvePromise(outcome);
         };
-        // Title + hint drawn once; entry rows below it (C-P7).
-        stderr.write(`${TITLE}\n`);
-        drawRows();
+        // Title + hint drawn once; entry rows below it get repainted (C-P7).
+        drawFrame();
         emitKeypressEvents(stdin);
         onKeypress = (_str, key) => {
             try {
@@ -1968,13 +2175,15 @@ function pickProviderInteractive(entries, initialIndex) {
                 }
                 if (key === undefined)
                     return;
-                const action = applyPickerKey(key, index, rowCount);
+                // Movement covers entry rows only (the 末行提示 is not selectable).
+                const action = applyPickerKey(key, index, entries.length);
                 if (action.type === "move") {
                     index = action.index;
                     redraw();
                 }
                 else if (action.type === "confirm") {
-                    // The last row is the 不切换 row → skip (D4).
+                    // index is always an entry row; the guard only matters for the
+                    // empty-list edge (nothing selectable → skip).
                     finish(index < entries.length
                         ? { kind: "select", entry: entries[index] }
                         : { kind: "skip" });
@@ -1994,12 +2203,213 @@ function pickProviderInteractive(entries, initialIndex) {
         // skip rather than hang.
         onGone = () => finish({ kind: "skip" });
         stdin.on("keypress", onKeypress);
+        stdin.on("data", onDataFastEsc);
         stdin.once("close", onGone);
         stdin.once("error", onGone);
         if (stdin.isTTY)
             stdin.setRawMode(true);
     });
 }
+/**
+ * Extract the `--settings <json>` value from one joined ps argv line: scan
+ * from the first `{` after `--settings` with string-aware bracket balancing
+ * (ps concatenates argv with spaces, so the JSON may contain any whitespace,
+ * and the payload itself nests objects). Returns undefined when the line has
+ * no `--settings`, no `{` after it, or never closes — the caller treats that
+ * as unattributable (honest: `--settings <file>` cannot be attributed either).
+ */
+function extractSettingsJson(line) {
+    const marker = line.indexOf("--settings");
+    if (marker === -1)
+        return undefined;
+    const start = line.indexOf("{", marker);
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < line.length; i++) {
+        const ch = line[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return line.slice(start, i + 1);
+        }
+    }
+    return undefined;
+}
+/**
+ * Whether one process's settings env matches a provider: baseUrl strict-equal
+ * AND (authToken strict-equal OR apiKey strict-equal) — empty/missing tokens
+ * never participate, so a bare URL can never match anything (same-domain
+ * dual-plan providers are told apart by token).
+ */
+function sessionProviderMatches(provider, baseUrl, authToken, apiKey) {
+    if (baseUrl === undefined || provider.baseUrl !== baseUrl)
+        return false;
+    const tokenHit = authToken !== undefined &&
+        authToken !== "" &&
+        provider.authToken === authToken;
+    const keyHit = apiKey !== undefined && apiKey !== "" && provider.apiKey === apiKey;
+    return tokenHit || keyHit;
+}
+/**
+ * Attribute joined ps argv lines to providers (pure, total — never throws).
+ * Lines with a parseable `--settings` env matching a provider increment that
+ * provider's count; providers with identical URL+token each count the same
+ * line (accepted edge). Bare claude lines, unparseable JSON, and settings
+ * matching no provider all count as `unattributed`.
+ */
+export function parseSessionAttribution(lines, providers) {
+    const counts = {};
+    let unattributed = 0;
+    for (const line of lines) {
+        const json = extractSettingsJson(line);
+        if (json === undefined) {
+            unattributed++;
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch {
+            unattributed++;
+            continue;
+        }
+        const env = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed.env
+            : undefined;
+        if (typeof env !== "object" || env === null || Array.isArray(env)) {
+            unattributed++;
+            continue;
+        }
+        const rec = env;
+        const baseUrl = typeof rec.ANTHROPIC_BASE_URL === "string"
+            ? rec.ANTHROPIC_BASE_URL
+            : undefined;
+        const authToken = typeof rec.ANTHROPIC_AUTH_TOKEN === "string"
+            ? rec.ANTHROPIC_AUTH_TOKEN
+            : undefined;
+        const apiKey = typeof rec.ANTHROPIC_API_KEY === "string"
+            ? rec.ANTHROPIC_API_KEY
+            : undefined;
+        const hits = providers.filter((p) => sessionProviderMatches(p, baseUrl, authToken, apiKey));
+        if (hits.length === 0) {
+            unattributed++;
+            continue;
+        }
+        for (const p of hits) {
+            counts[p.name] = (counts[p.name] ?? 0) + 1;
+        }
+    }
+    return { counts, unattributed };
+}
+/**
+ * Glue for the claude TTY menu path: scan live processes once and attribute
+ * them. Any failure (deps capability missing, spawn error, non-zero pgrep/ps)
+ * resolves to undefined — the caller degrades to no session column and no
+ * bare-session footer (cannot distinguish "none" from "scan failed"; prefer
+ * silence over a wrong number). Never throws.
+ */
+async function countProviderSessions(deps, providers) {
+    if (deps.listClaudeProcessArgs === undefined)
+        return undefined;
+    try {
+        const lines = await deps.listClaudeProcessArgs();
+        return parseSessionAttribution(lines, providers);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Production deps.listClaudeProcessArgs: `pgrep -x claude` for pids, then
+ * `ps -ww -o command= -p <pids>` (BSD flags; `-ww` defeats column truncation
+ * so long argv carrying `--settings` JSON survives). Read-only, no secrets in
+ * the commands themselves; ps output (which contains tokens) stays in memory.
+ * Exit semantics: pgrep 1 = no match → []; pgrep >1 or any ps failure →
+ * rejects (error text carries only exit codes / ps stderr — never ps stdout).
+ */
+function listClaudeProcessArgsOnDisk() {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const pgrep = spawn("pgrep", ["-x", CLAUDE_BIN], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let pidsOut = "";
+        let pgrepErr = "";
+        pgrep.stdout.on("data", (chunk) => {
+            pidsOut += chunk.toString();
+        });
+        pgrep.stderr.on("data", (chunk) => {
+            pgrepErr += chunk.toString();
+        });
+        pgrep.on("error", (err) => {
+            rejectPromise(new Error(`pgrep failed to spawn: ${err.message}`));
+        });
+        pgrep.on("close", (code) => {
+            if (code === 1) {
+                resolvePromise([]); // no processes matched — not an error
+                return;
+            }
+            if (code !== 0) {
+                const msg = pgrepErr.trim();
+                rejectPromise(new Error(msg
+                    ? `pgrep exited with code ${code}: ${msg}`
+                    : `pgrep exited with code ${code}`));
+                return;
+            }
+            const pids = pidsOut
+                .split("\n")
+                .map((s) => s.trim())
+                .filter((s) => s !== "");
+            if (pids.length === 0) {
+                resolvePromise([]);
+                return;
+            }
+            const ps = spawn("ps", ["-ww", "-o", "command=", "-p", pids.join(",")], {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let psOut = "";
+            let psErr = "";
+            ps.stdout.on("data", (chunk) => {
+                psOut += chunk.toString();
+            });
+            ps.stderr.on("data", (chunk) => {
+                psErr += chunk.toString();
+            });
+            ps.on("error", (err) => {
+                rejectPromise(new Error(`ps failed to spawn: ${err.message}`));
+            });
+            ps.on("close", (psCode) => {
+                if (psCode !== 0) {
+                    const msg = psErr.trim();
+                    rejectPromise(new Error(msg
+                        ? `ps exited with code ${psCode}: ${msg}`
+                        : `ps exited with code ${psCode}`));
+                    return;
+                }
+                resolvePromise(psOut
+                    .split("\n")
+                    .map((s) => s.trimEnd())
+                    .filter((s) => s !== ""));
+            });
+        });
+    });
+}
 // ---------------------------------------------------------------------------
 // Last-provider memory (D2) — production deps.readLastProvider/writeLastProvider
 // ---------------------------------------------------------------------------
@@ -2315,8 +2725,8 @@ claude backend (default; bare \`gcli ...\` === \`gcli claude ...\`):
       does NOT rewrite ~/.claude/settings.json.
     - No --provider in a TTY: gcli lists all cc-switch providers (in
       cc-switch's own DB order) in an arrow-key picker (↑↓/j/k and Emacs
-      C-n/C-p move · Enter 确认 · Esc/C-g = 不切换, keep claude's default
-      config; M-</M-> jump to first/last; ctrl-c exits 130). In print mode
+      C-n/C-p move · Enter 确认 · Esc/C-g = 退出（不启动 claude）;
+      M-</M-> jump to first/last; ctrl-c exits 130). In print mode
       (-p) the last confirmed provider is reused silently (one stderr hint
       line); the menu only pops when nothing valid is remembered, or when
       --pick is given. Without a TTY the picker never triggers — no prompt,
@@ -2566,6 +2976,7 @@ async function runClaudeBackend(parsed, deps) {
         }
     }
     let settingsEnv;
+    let pickerSkipped = false;
     let pickerWarning;
     if (parsed.provider !== undefined) {
         const validated = validateProviderName(parsed.provider);
@@ -2666,17 +3077,45 @@ async function runClaudeBackend(parsed, deps) {
                             quotaItems.push({ name: p.name, env: envResult.env });
                         }
                     }
-                    const quotaMap = await deps.fetchProviderQuotas(quotaItems);
+                    // Session attribution runs once, in parallel with the quota fetch,
+                    // on this menu path only. Any failure resolves to undefined and the
+                    // picker degrades to no session column (same soft-degrade as quota).
+                    const sessionProviders = quotaItems.map((q) => ({
+                        name: q.name,
+                        baseUrl: q.env.ANTHROPIC_BASE_URL,
+                        authToken: q.env.ANTHROPIC_AUTH_TOKEN,
+                        apiKey: q.env.ANTHROPIC_API_KEY,
+                    }));
+                    const [quotaMap, attribution] = await Promise.all([
+                        deps.fetchProviderQuotas(quotaItems),
+                        countProviderSessions(deps, sessionProviders),
+                    ]);
                     // D5/D6 (revise-3): rows are name + quota subtitle (host is gone);
-                    // the remembered row gets a（上次）marker after the subtitle.
+                    // the remembered row carries its ●上次 marker as a structured tag
+                    // (rendering decides placement/color; quota text stays byte-clean).
+                    // Live-session counts ride the same rows (0 included); undefined
+                    // when the scan was unavailable so the column degrades per entry.
+                    // The frame-level bare-claude count rides every entry too (same
+                    // value) so the footer hint survives pickProvider wrappers that
+                    // forward only (entries, initialIndex); undefined → degrade to 0.
                     const entries = ordered.map((p) => {
-                        let quota = quotaMap.get(p.name);
+                        const entry = {
+                            name: p.name,
+                            quota: quotaMap.get(p.name),
+                            sessions: attribution === undefined
+                                ? undefined
+                                : (attribution.counts[p.name] ?? 0),
+                            unattributed: attribution?.unattributed,
+                        };
                         if (remembered !== undefined && p.name === remembered) {
-                            quota = quota !== undefined ? `${quota}（上次）` : "（上次）";
+                            entry.tag = "上次";
                         }
-                        return { name: p.name, quota };
+                        return entry;
                     });
-                    const picked = await deps.pickProvider(entries, memoryValid ? memoryIndex : 0);
+                    const picked = await deps.pickProvider(entries, memoryValid ? memoryIndex : 0, 
+                    // Degraded scan → 0: cannot distinguish "no bare sessions" from
+                    // "scan failed", so the footer hint stays silent either way.
+                    attribution?.unattributed ?? 0);
                     if (picked.kind === "select") {
                         // Exact-name lookup (no matchProviderName): the picker returns
                         // an entry straight from this list.
@@ -2694,7 +3133,10 @@ async function runClaudeBackend(parsed, deps) {
                             await deps.writeLastProvider(picked.entry.name);
                         }
                     }
-                    // skip → keep claude's default config; memory untouched.
+                    else {
+                        pickerSkipped = true; // Esc/C-g → 退出，不启动 claude
+                    }
+                    // skip 语义（2026-09 用户裁定）：退出。memory untouched.
                 }
             }
         }
@@ -2713,6 +3155,15 @@ async function runClaudeBackend(parsed, deps) {
             ...o,
             stderr: o.stderr ? `${pickerWarning}\n${o.stderr}` : pickerWarning,
         };
+    // Esc/C-g skip = 退出（2026-09 用户裁定，替代旧「不切换照常启动」语义）：
+    // 不 spawn 任何后端，干净退出 exit 0。stderr 提示确认动作已被感知。
+    if (pickerSkipped) {
+        return withPickerWarning({
+            exitCode: 0,
+            stdout: "",
+            stderr: "gcli: 已退出（未启动 claude）",
+        });
+    }
     const cwdAbs = parsed.cwd ? resolve(parsed.cwd) : undefined;
     // Interactive mode (no -p in a TTY): inherit stdio, pass exit code through.
     if (prompt === undefined) {
@@ -3411,8 +3862,9 @@ async function main() {
         runClaudeInteractive: (args, cwd) => runClaudeInteractive(args, cwd),
         runAgyInteractive: (args, cwd) => runAgyInteractive(args, cwd),
         isInteractive: () => process.stdin.isTTY === true,
-        pickProvider: (entries, initialIndex) => pickProviderInteractive(entries, initialIndex),
+        pickProvider: (entries, initialIndex, unattributedCount) => pickProviderInteractive(entries, initialIndex, unattributedCount),
         fetchProviderQuotas: (items) => fetchProviderQuotasHttp(items),
+        listClaudeProcessArgs: () => listClaudeProcessArgsOnDisk(),
         readLastProvider: () => readLastProviderFromDisk(),
         writeLastProvider: (name) => writeLastProviderToDisk(name),
         runHermes: (args, timeoutMs) => runHermesProcess(args, timeoutMs ?? DEFAULT_TIMEOUT_MS),