@triflux/core 10.53.0 → 10.55.0

package/hub/team/retry-state-machine.mjs

@@ -1,6 +1,6 @@
 // hub/team/retry-state-machine.mjs
 // Phase 3 Step A — true ralph / auto-escalate retry state machine.
-// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+// 설계: 구현 커밋 565a2bad 메시지, 규칙은 .claude/rules/tfx-escalation-chain.md
 //
 // Modes:
 //   bounded       — --retry 1 (기본): maxIterations 도달 시 BUDGET_EXCEEDED.

package/hub/team/session.mjs

@@ -0,0 +1,541 @@
+// tmux/psmux 세션 생명주기 관리
+import { execFileSync, spawnSync } from "node:child_process";
+import { resolveGitBashExecutable } from "../lib/bash-path.mjs";
+import { getEnvironment } from "../lib/env-detect.mjs";
+import {
+  attachPsmuxSession,
+  capturePsmuxPane,
+  configurePsmuxKeybindings,
+  createPsmuxSession,
+  getMultiplexerType,
+  getPsmuxSessionAttachedCount,
+  hasMultiplexer,
+  killPsmuxSession,
+  listPsmuxSessions,
+  psmuxExec,
+  psmuxSessionExists,
+  tokenizeCommand,
+} from "./psmux.mjs";
+
+/** Windows Terminal 실행 파일 존재 여부 */
+export function hasWindowsTerminal() {
+  return !!getEnvironment().terminal.hasWt;
+}
+
+/** 현재 프로세스가 Windows Terminal 내에서 실행 중인지 여부 */
+export function hasWindowsTerminalSession() {
+  return process.platform === "win32" && !!process.env.WT_SESSION;
+}
+
+/** tmux 실행 가능 여부 확인 */
+function hasTmux() {
+  try {
+    execFileSync("tmux", ["-V"], {
+      stdio: "ignore",
+      timeout: 3000,
+      windowsHide: true,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Git Bash 내 tmux 사용 가능 여부 (Windows 전용) */
+function hasGitBashTmux() {
+  const bash = resolveGitBashExecutable();
+  if (!bash) return false;
+  try {
+    const r = spawnSync(bash, ["-lc", "tmux -V"], {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    return (r.status ?? 1) === 0;
+  } catch {
+    return false;
+  }
+}
+
+function isPsmuxCommandName(command) {
+  const name = String(command || "")
+    .replace(/\\/g, "/")
+    .split("/")
+    .pop()
+    .toLowerCase();
+  return name === "psmux" || name === "psmux.exe" || name === "psmux.cmd";
+}
+
+/**
+ * 터미널 멀티플렉서 감지 (결과 캐싱 — 프로세스 수명 동안 불변)
+ * @returns {'tmux'|'git-bash-tmux'|'psmux'|null}
+ */
+let _cachedMux;
+export function detectMultiplexer() {
+  if (_cachedMux !== undefined) return _cachedMux;
+
+  if (process.platform !== "win32") {
+    const primaryMux = getMultiplexerType();
+    if (primaryMux === "tmux" && hasMultiplexer()) {
+      _cachedMux = "tmux";
+      return _cachedMux;
+    }
+    if (hasTmux()) {
+      _cachedMux = "tmux";
+      return _cachedMux;
+    }
+    _cachedMux = null;
+    return _cachedMux;
+  }
+
+  if (hasMultiplexer() && isPsmuxCommandName(getMultiplexerType())) {
+    _cachedMux = "psmux";
+    return _cachedMux;
+  }
+  if (hasTmux()) {
+    _cachedMux = "tmux";
+    return _cachedMux;
+  }
+  if (hasGitBashTmux()) {
+    _cachedMux = "git-bash-tmux";
+    return _cachedMux;
+  }
+  _cachedMux = null;
+  return _cachedMux;
+}
+
+function bashArg(value) {
+  return /^[\w@%+=:,./-]+$/u.test(value)
+    ? value
+    : `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * tmux/psmux 커맨드 실행
+ * @param {string[]|string} args: tmux 서브커맨드 + 인자. 문자열은 psmux 와 같은 규칙으로 쪼갠다.
+ * @param {object} opts: execFileSync 옵션
+ * @returns {string} stdout
+ */
+function tmux(args, opts = {}) {
+  const mux = detectMultiplexer();
+  if (!mux) {
+    throw new Error(
+      "tmux/psmux 미발견.\n\n" +
+        "tfx multi은 tmux 계열 멀티플렉서가 필요합니다:\n" +
+        "  Windows: psmux 설치\n" +
+        "  macOS:  brew install tmux\n" +
+        "  Linux:  apt install tmux",
+    );
+  }
+  if (mux === "psmux") {
+    return psmuxExec(args, opts);
+  }
+  // 셸을 거치지 않게 인자 배열로 넘긴다. 세션 이름이나 pane 대상이 셸 문법으로 읽히지 않는다.
+  const argv = Array.isArray(args) ? args.map(String) : tokenizeCommand(args);
+  if (mux === "git-bash-tmux") {
+    const bash = resolveGitBashExecutable();
+    if (!bash) throw new Error("git-bash-tmux 감지 실패");
+    const r = spawnSync(
+      bash,
+      ["-lc", ["tmux", ...argv.map(bashArg)].join(" ")],
+      {
+        encoding: "utf8",
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        ...opts,
+      },
+    );
+    if ((r.status ?? 1) !== 0) {
+      const e = new Error(r.stderr || "tmux command failed");
+      e.status = r.status;
+      throw e;
+    }
+    return (r.stdout || "").trim();
+  }
+
+  const result = execFileSync("tmux", argv, {
+    encoding: "utf8",
+    timeout: 10000,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+    ...opts,
+  });
+  return result != null ? result.trim() : "";
+}
+
+/**
+ * tmux 명령 직접 실행 (고수준 모듈에서 재사용)
+ * @param {string[]|string} args
+ * @param {object} opts
+ * @returns {string}
+ */
+export function tmuxExec(args, opts = {}) {
+  return tmux(args, opts);
+}
+
+/**
+ * 현재 멀티플렉서 환경에 맞는 attach 실행 스펙 반환
+ * @param {string} sessionName
+ * @returns {{ command: string, args: string[] }}
+ */
+export function resolveAttachCommand(sessionName, opts = {}) {
+  const mux = opts.mux || detectMultiplexer();
+  if (!mux) {
+    throw new Error("tmux/psmux 미발견");
+  }
+
+  if (mux === "psmux") {
+    return {
+      command: process.env.PSMUX_BIN || "psmux",
+      args: ["attach-session", "-t", sessionName],
+    };
+  }
+
+  if (mux === "git-bash-tmux") {
+    const bash = opts.bashCommand || resolveGitBashExecutable();
+    if (!bash) throw new Error("git-bash-tmux 감지 실패");
+    return {
+      command: bash,
+      args: ["-lc", `tmux attach-session -t ${bashArg(sessionName)}`],
+    };
+  }
+
+  return {
+    command: "tmux",
+    args: ["attach-session", "-t", sessionName],
+  };
+}
+
+/**
+ * tmux 세션 생성 + 레이아웃 분할
+ * @param {string} sessionName — 세션 이름
+ * @param {object} opts
+ * @param {'2x2'|'1xN'|'Nx1'} opts.layout — 레이아웃 (기본 2x2)
+ * @param {number} opts.paneCount — pane 수 (기본 4)
+ * @returns {{ sessionName: string, panes: string[] }}
+ */
+export function createSession(sessionName, opts = {}) {
+  const { layout = "2x2", paneCount = 4 } = opts;
+  const mux = detectMultiplexer();
+
+  // 기존 세션 정리
+  if (sessionExists(sessionName)) {
+    killSession(sessionName);
+  }
+
+  if (mux === "psmux") {
+    return createPsmuxSession(sessionName, { layout, paneCount });
+  }
+
+  // 새 세션 생성 (detached)
+  tmux(["new-session", "-d", "-s", sessionName, "-x", "220", "-y", "55"]);
+
+  const panes = [`${sessionName}:0.0`];
+
+  if (layout === "2x2" && paneCount >= 3) {
+    // 3-pane 기본: lead 왼쪽, workers 오른쪽 상/하
+    // 4-pane: 좌/우 각각 상/하(균등 2x2)
+    tmux(["split-window", "-h", "-t", `${sessionName}:0.0`]);
+    tmux(["split-window", "-v", "-t", `${sessionName}:0.1`]);
+    if (paneCount >= 4) {
+      tmux(["split-window", "-v", "-t", `${sessionName}:0.0`]);
+    }
+    // pane ID 재수집
+    panes.length = 0;
+    for (let i = 0; i < Math.min(paneCount, 4); i++) {
+      panes.push(`${sessionName}:0.${i}`);
+    }
+  } else if (layout === "1xN") {
+    // 세로 분할(좌/우 컬럼 확장)
+    for (let i = 1; i < paneCount; i++) {
+      tmux(["split-window", "-h", "-t", `${sessionName}:0`]);
+    }
+    tmux(["select-layout", "-t", `${sessionName}:0`, "even-horizontal"]);
+    panes.length = 0;
+    for (let i = 0; i < paneCount; i++) {
+      panes.push(`${sessionName}:0.${i}`);
+    }
+  } else {
+    // Nx1 가로 분할(상/하 스택)
+    for (let i = 1; i < paneCount; i++) {
+      tmux(["split-window", "-v", "-t", `${sessionName}:0`]);
+    }
+    tmux(["select-layout", "-t", `${sessionName}:0`, "even-vertical"]);
+    panes.length = 0;
+    for (let i = 0; i < paneCount; i++) {
+      panes.push(`${sessionName}:0.${i}`);
+    }
+  }
+
+  return { sessionName, panes };
+}
+
+/**
+ * pane 포커스 이동
+ * @param {string} target
+ * @param {object} opts
+ * @param {boolean} opts.zoom
+ */
+export function focusPane(target, opts = {}) {
+  const { zoom = false } = opts;
+  tmux(["select-pane", "-t", target]);
+  if (zoom) {
+    try {
+      tmux(["resize-pane", "-t", target, "-Z"]);
+    } catch {}
+  }
+}
+
+/**
+ * 팀메이트 조작 키 바인딩 설정
+ * - Shift+Down: 다음 팀메이트
+ * - Shift+Up: 이전 팀메이트
+ * - Shift+Left / Shift+Tab: 이전 팀메이트 대체 키
+ * - Shift+Right: 다음 팀메이트 대체 키
+ * - Escape: 현재 팀메이트 인터럽트(C-c)
+ * - Ctrl+T: 태스크 목록 표시
+ * @param {string} sessionName
+ * @param {object} opts
+ * @param {boolean} opts.inProcess
+ * @param {string} opts.taskListCommand
+ */
+export function configureTeammateKeybindings(sessionName, opts = {}) {
+  if (detectMultiplexer() === "psmux") {
+    configurePsmuxKeybindings(sessionName, opts);
+    return;
+  }
+
+  const { inProcess = false, taskListCommand = "" } = opts;
+  const cond = `#{==:#{session_name},${sessionName}}`;
+
+  // Shift+Up이 터미널/호스트 조합에 따라 전달되지 않는 경우가 있어
+  // 좌/우/Shift+Tab 대체 키를 함께 바인딩한다.
+  const bindNext = inProcess
+    ? "select-pane -t :.+ \\; resize-pane -Z"
+    : "select-pane -t :.+";
+  const bindPrev = inProcess
+    ? "select-pane -t :.- \\; resize-pane -Z"
+    : "select-pane -t :.-";
+  const bindIf = (key, onMatch, otherwise) =>
+    tmux([
+      "bind-key",
+      "-T",
+      "root",
+      "-n",
+      key,
+      "if-shell",
+      "-F",
+      cond,
+      onMatch,
+      otherwise,
+    ]);
+
+  bindIf("S-Down", bindNext, "send-keys S-Down");
+  bindIf("S-Up", bindPrev, "send-keys S-Up");
+
+  // 대체 키: 일부 환경에서 S-Up이 누락될 때 사용
+  bindIf("S-Right", bindNext, "send-keys S-Right");
+  bindIf("S-Left", bindPrev, "send-keys S-Left");
+  bindIf("BTab", bindPrev, "send-keys BTab");
+
+  // 현재 활성 pane 인터럽트
+  bindIf("Escape", "send-keys C-c", "send-keys Escape");
+
+  // 태스크 목록 토글 (tmux 3.2+ popup 우선, 실패 시 안내 메시지)
+  if (taskListCommand) {
+    const escaped = taskListCommand.replace(/'/g, "'\\''");
+    try {
+      bindIf("C-t", `display-popup -E '${escaped}'`, "send-keys C-t");
+    } catch {
+      bindIf(
+        "C-t",
+        'display-message "tfx multi tasks 명령으로 태스크 확인"',
+        "send-keys C-t",
+      );
+    }
+  }
+}
+
+/**
+ * tmux 세션 연결 (포그라운드 전환)
+ * @param {string} sessionName
+ */
+export function attachSession(sessionName) {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    throw new Error("현재 터미널은 tmux attach를 지원하지 않음 (non-TTY)");
+  }
+
+  if (detectMultiplexer() === "psmux") {
+    attachPsmuxSession(sessionName);
+    return;
+  }
+
+  const { command, args } = resolveAttachCommand(sessionName);
+  const r = spawnSync(command, args, {
+    stdio: "inherit",
+    timeout: 0, // 타임아웃 없음 (사용자가 detach할 때까지)
+  });
+  if ((r.status ?? 1) !== 0) {
+    throw new Error(`tmux attach 실패 (exit=${r.status})`);
+  }
+}
+
+/**
+ * non-TTY 환경용 attach fallback: 요청 프로세스가 명시적으로 넘긴 lead pane을
+ * 분할해 그 pane 안에서 대상 세션에 attach한다.
+ *
+ * 호출 프로세스가 pipe(non-TTY)로 실행돼 attachSession()이 불가능해도,
+ * tmux 서버에 보내는 split-window는 호출자 TTY가 필요 없다. 새 pane에는
+ * tmux가 실제 pty를 붙여주므로 그 안의 attach는 정상 동작한다.
+ * env -u TMUX는 nested-attach 보호 해제용이다.
+ *
+ * @param {string} sessionName attach할 대상 세션
+ * @param {string} targetPane 요청 lead의 `$TMUX_PANE` (`%N`)
+ * @param {string} tmuxEnv 요청 lead의 `$TMUX` (`socket,pid,index`)
+ * @returns {boolean} 분할 attach 성공 여부 (false면 호출자가 기존 생략 경로 유지)
+ */
+export function buildSplitAttachArgs(sessionName, targetPane, tmuxEnv) {
+  const normalizedSessionName = String(sessionName || "");
+  if (!normalizedSessionName.trim()) {
+    throw new Error("session name is required");
+  }
+  if (!/^%\d+$/u.test(String(targetPane || ""))) {
+    throw new Error("requesting lead TMUX_PANE is required");
+  }
+  const socketPath = String(tmuxEnv || "").split(",", 1)[0];
+  if (!socketPath.trim()) {
+    throw new Error("requesting lead TMUX socket is required");
+  }
+  const quotedSocket = `'${socketPath.replace(/'/gu, "'\\''")}'`;
+  const quotedSessionName = `'${normalizedSessionName.replace(/'/gu, "'\\''")}'`;
+  return [
+    "split-window",
+    "-t",
+    targetPane,
+    "-v",
+    "-l",
+    "50%",
+    `env -u TMUX tmux -S ${quotedSocket} attach -t ${quotedSessionName}`,
+  ];
+}
+
+export function splitAttachToClient(sessionName, opts = {}) {
+  const deps = opts._deps || {};
+  const detectMux = deps.detectMultiplexer || detectMultiplexer;
+  if (detectMux() !== "tmux") return false;
+
+  let args;
+  try {
+    args = buildSplitAttachArgs(sessionName, opts.targetPane, opts.tmuxEnv);
+  } catch {
+    return false;
+  }
+
+  // 상하 분할: 좌우 분할은 절반 폭이 워커 pane 가독 하한(100cols) 미만인 경우가 흔함
+  const spawn = deps.spawnSync || spawnSync;
+  const split = spawn("tmux", args);
+  return (split.status ?? 1) === 0;
+}
+
+/**
+ * tmux 세션 존재 확인
+ * @param {string} sessionName
+ * @returns {boolean}
+ */
+export function sessionExists(sessionName) {
+  if (detectMultiplexer() === "psmux") {
+    return psmuxSessionExists(sessionName);
+  }
+
+  try {
+    // '=' 가 없으면 tmux 가 접두사로 다른 세션을 잡는다(#548).
+    tmux(["has-session", "-t", `=${sessionName}`], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * tmux 세션 종료
+ * @param {string} sessionName
+ */
+export function killSession(sessionName) {
+  if (detectMultiplexer() === "psmux") {
+    killPsmuxSession(sessionName);
+    return;
+  }
+
+  try {
+    tmux(["kill-session", "-t", `=${sessionName}`], { stdio: "ignore" });
+  } catch {
+    // 이미 종료된 세션 — 무시
+  }
+}
+
+/**
+ * tfx-multi- 접두사 세션 목록
+ * @returns {string[]}
+ */
+export function listSessions() {
+  if (detectMultiplexer() === "psmux") {
+    return listPsmuxSessions();
+  }
+
+  try {
+    const output = tmux(["list-sessions", "-F", "#{session_name}"]);
+    return output.split("\n").filter((s) => s.startsWith("tfx-multi-"));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 세션 attach client 수 조회
+ * @param {string} sessionName
+ * @returns {number|null}
+ */
+export function getSessionAttachedCount(sessionName) {
+  if (detectMultiplexer() === "psmux") {
+    return getPsmuxSessionAttachedCount(sessionName);
+  }
+
+  try {
+    const output = tmux([
+      "list-sessions",
+      "-F",
+      "#{session_name} #{session_attached}",
+    ]);
+    const line = output
+      .split("\n")
+      .find((l) => l.startsWith(`${sessionName} `));
+    if (!line) return null;
+    const n = parseInt(line.split(" ")[1], 10);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * pane 마지막 N줄 캡처
+ * @param {string} target — 예: tfx-multi-abc:0.1
+ * @param {number} lines — 캡처할 줄 수 (기본 5)
+ * @returns {string}
+ */
+export function capturePaneOutput(target, lines = 5) {
+  if (detectMultiplexer() === "psmux") {
+    return capturePsmuxPane(target, lines);
+  }
+
+  try {
+    // -l 플래그는 일부 tmux 빌드(MSYS2)에서 미지원 → 전체 캡처 후 JS에서 절삭
+    const full = tmux(["capture-pane", "-t", target, "-p"]);
+    const nonEmpty = full.split("\n").filter((l) => l.trim() !== "");
+    return nonEmpty.slice(-lines).join("\n");
+  } catch {
+    return "";
+  }
+}

package/hud/constants.mjs

@@ -82,9 +82,6 @@ export const OMC_PLUGIN_USAGE_CACHE_PATH = join(
 export const CLAUDE_USAGE_STALE_MS_SOLO = 5 * 60 * 1000; // OMC 없을 때: 5분 캐시
 export const CLAUDE_USAGE_STALE_MS_WITH_OMC = 15 * 60 * 1000; // OMC 있을 때: 15분
 export const CLAUDE_USAGE_429_BACKOFF_MS = 10 * 60 * 1000; // 429 에러 시 10분 backoff
-export const GEMINI_429_BASE_DELAY_MS = 2000;
-export const GEMINI_429_MAX_RETRIES = 3;
-export const GEMINI_429_COOLDOWN_MS = 30000;
 export const CLAUDE_USAGE_ERROR_BACKOFF_MS = 3 * 60 * 1000; // 기타 에러 시 3분 backoff
 export const CLAUDE_API_TIMEOUT_MS = 10_000;
 export const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;

package/hud/providers/claude.mjs

@@ -182,8 +182,19 @@ function readClaudeKeychainCredentials(
   const entry = readClaudeKeychainEntry({ execFileSyncFn, env });
   if (!entry) return null;
   const creds = normalizeClaudeCredentials(entry.raw, "keychain");
+  if (!creds) return null;
   // 만료된 항목도 그대로 돌려준다. 호출자가 refreshToken 으로 갱신한 뒤 같은 항목에 되쓴다.
-  return creds ? { ...creds, keychainAccount: entry.account } : null;
+  const lineLength = keychainWriteLine(
+    entry.account,
+    entry.serviceName,
+    entry.raw,
+  ).length;
+  return {
+    ...creds,
+    keychainAccount: entry.account,
+    keychainWritable:
+      lineLength + KEYCHAIN_TOKEN_GROWTH_MARGIN <= KEYCHAIN_STDIN_LINE_LIMIT,
+  };
 }
 
 // 읽기 순서는 Claude Code 와 같다. macOS 에서는 Keychain 이 정본이고 평문 파일은 Keychain 을 못 쓸 때의
@@ -316,8 +327,16 @@ function mergeClaudeCredentials(creds, existingRaw) {
 }
 
 // Claude Code 와 같은 쓰기 경로: 비밀값을 argv 에 두지 않도록 `security -i` 표준입력으로 명령 한 줄을
-// 넘기고 payload 는 `-X` 16진수로 싣는다. 한 줄 상한(4032B)을 넘는 큰 항목만 argv 로 내려간다.
+// 넘기고 payload 는 `-X` 16진수로 싣는다. 한 줄 상한(4032B)을 넘는 큰 항목은 argv 로 넘기면 토큰이
+// ps 에 보여서 되쓰지 않는다.
 const KEYCHAIN_STDIN_LINE_LIMIT = 4032;
+// 갱신 뒤 토큰 길이가 조금 달라져도 상한을 넘지 않도록 둔 여유(글자 수).
+const KEYCHAIN_TOKEN_GROWTH_MARGIN = 512;
+
+function keychainWriteLine(account, serviceName, payload) {
+  const hex = Buffer.from(JSON.stringify(payload), "utf8").toString("hex");
+  return `add-generic-password -U -a "${account}" -s "${serviceName}" -X "${hex}"\n`;
+}
 
 function writeClaudeKeychainCredentials(
   creds,
@@ -333,20 +352,17 @@ function writeClaudeKeychainCredentials(
     execFileSyncFn,
   );
   const payload = mergeClaudeCredentials(creds, existingRaw);
-  const hex = Buffer.from(JSON.stringify(payload), "utf8").toString("hex");
-  const line = `add-generic-password -U -a "${account}" -s "${serviceName}" -X "${hex}"\n`;
-  if (line.length <= KEYCHAIN_STDIN_LINE_LIMIT) {
-    execFileSyncFn("security", ["-i"], {
-      input: line,
-      stdio: ["pipe", "ignore", "ignore"],
-    });
+  const line = keychainWriteLine(account, serviceName, payload);
+  if (line.length > KEYCHAIN_STDIN_LINE_LIMIT) {
+    process.stderr.write(
+      "[hud] Keychain 항목이 커서 갱신한 토큰을 되쓰지 않습니다\n",
+    );
     return;
   }
-  execFileSyncFn(
-    "security",
-    ["add-generic-password", "-U", "-a", account, "-s", serviceName, "-X", hex],
-    { stdio: "ignore" },
-  );
+  execFileSyncFn("security", ["-i"], {
+    input: line,
+    stdio: ["pipe", "ignore", "ignore"],
+  });
 }
 
 function writeClaudeFileCredentials(
@@ -631,7 +647,11 @@ export async function fetchClaudeUsage(forceRefresh = false) {
 
   // 토큰 만료 시 리프레시
   if (creds.expiresAt && creds.expiresAt <= Date.now() && creds.refreshToken) {
-    const refreshed = await refreshClaudeAccessToken(creds.refreshToken);
+    // 되쓰지 못할 갱신은 회전된 refreshToken 을 잃어 Claude Code 로그인을 풀 수 있다. 갱신은 Claude Code 에 맡긴다.
+    const refreshed =
+      creds.keychainWritable === false
+        ? null
+        : await refreshClaudeAccessToken(creds.refreshToken);
     if (refreshed) {
       creds = { ...creds, ...refreshed };
       writeBackClaudeCredentials(creds);