@cartanova/qgrid-cli 2.6.1 → 2.6.4

package/bundle/src/application/qgrid/oauth.ts

@@ -117,6 +117,25 @@ export async function exchangeCodeForTokens(
   };
 }
 
+/**
+ * refresh 실패를 status 와 함께 전달한다. 호출부가 문자열 메시지를 파싱하지 않고
+ * 영구 실패(400/401)를 판별할 수 있어야 하기 때문이다.
+ */
+export class RefreshFailedError extends Error {
+  override readonly name = "RefreshFailedError";
+  constructor(
+    readonly status: number,
+    readonly body: string,
+  ) {
+    super(`Token refresh failed (${status}): ${body}`);
+  }
+
+  /** 재로그인 외 복구 불가한 인증 실패인지. 일시 오류(5xx·네트워크)는 제외된다. */
+  get isAuthDead(): boolean {
+    return this.status === 400 || this.status === 401;
+  }
+}
+
 export async function refreshAccessToken(refreshToken: string): Promise<OAuthTokens> {
   const res = await fetch(TOKEN_URL, {
     method: "POST",
@@ -130,7 +149,7 @@ export async function refreshAccessToken(refreshToken: string): Promise<OAuthTok
   });
   if (!res.ok) {
     const text = await res.text();
-    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+    throw new RefreshFailedError(res.status, text);
   }
   const data = (await res.json()) as {
     access_token: string;

package/bundle/src/application/qgrid/qgrid-oauth-redirect.test.ts

@@ -37,6 +37,18 @@ vi.mock("../token/token.model", () => ({
     save: tokenSaveMock,
     del: tokenDelMock,
     findByAccountIdentifier: findByAccountMock,
+    // 실제 구현과 같은 순서(dedup → save)로 동작시켜 저장 payload 검증이 유지되게 한다.
+    replaceByAccount: async (
+      _provider: string,
+      accountId: string | undefined,
+      saveParams: unknown,
+    ) => {
+      if (accountId) {
+        const olds = (await findByAccountMock()) as unknown as { id: number; active: boolean }[];
+        if (olds.length > 0) await tokenDelMock();
+      }
+      await (tokenSaveMock as unknown as (rows: unknown[]) => Promise<number[]>)([saveParams]);
+    },
   },
 }));
 
@@ -106,7 +118,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
 
   it("exchanges a pasted code#state against the stored pending state and saves the token", async () => {
     mockHttpContext({ origin: "https://qgrid.example.com" });
-    const { authUrl } = await QgridFrame.oauthStart("haze-2");
+    const { authUrl } = await QgridFrame.oauthStart("test-token-2");
     const state = authUrlParam(authUrl, "state")!;
 
     exchangeMock.mockResolvedValueOnce({
@@ -119,7 +131,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
 
     await expect(QgridFrame.oauthComplete(`  the-code#${state} `)).resolves.toEqual({
       added: true,
-      name: "haze-2",
+      name: "test-token-2",
     });
 
     expect(exchangeMock).toHaveBeenCalledWith(
@@ -131,7 +143,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
     expect(tokenSaveMock).toHaveBeenCalledWith([
       expect.objectContaining({
         provider: "anthropic",
-        name: "haze-2",
+        name: "test-token-2",
         credentials: expect.objectContaining({ accessToken: "at", accountUuid: "acc-1" }),
       }),
     ]);

package/bundle/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -56,7 +56,7 @@ describe("QgridDispatcherClass", () => {
 
     await expect(
       dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6" }),
-    ).rejects.toThrow(/Anthropic dispatcher not initialized/);
+    ).rejects.toMatchObject({ statusCode: 503 });
   });
 
   it("AnthropicDispatcher 미초기화 시 queryStream 은 delta 없는 query 폴백 없이 실패한다", async () => {
@@ -71,7 +71,35 @@ describe("QgridDispatcherClass", () => {
           onError: vi.fn(),
         },
       ),
-    ).rejects.toThrow(/Anthropic dispatcher not initialized/);
+    ).rejects.toMatchObject({ statusCode: 503 });
+  });
+
+  // 기동 중과 초기화 실패는 클라이언트의 재시도 판단이 갈리는 지점이라 상태코드로 구분한다.
+  it("기동 중 미준비는 503 으로 재시도 가능함을 알린다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+
+    await expect(
+      dispatcher.query({ prompt: "hi", model: "openai/gpt-5.4" }),
+    ).rejects.toMatchObject({ statusCode: 503 });
+  });
+
+  it("초기화가 실패로 끝났으면 500 으로 재시도가 무의미함을 알린다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.startupState.openai = "failed";
+
+    await expect(
+      dispatcher.query({ prompt: "hi", model: "openai/gpt-5.4" }),
+    ).rejects.toMatchObject({ statusCode: 500 });
+  });
+
+  it("provider 별로 기동 상태를 따로 본다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.startupState.openai = "failed";
+
+    // openai 가 실패해도 anthropic 은 여전히 기동 중(재시도 가능)이다.
+    await expect(
+      dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6" }),
+    ).rejects.toMatchObject({ statusCode: 503 });
   });
 
   it("provider prefix 없는 모델은 AnthropicDispatcher 로 암묵 라우팅하지 않는다", async () => {

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -4,9 +4,13 @@
  * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신
  * - OpenAI/Anthropic 요청은 각 provider dispatcher 로만 실행
  * - QuotaError 는 그대로 상위 전파
+ * - dispatcher 미준비는 기동 중(503)/초기화 실패(500)로 구분해 던진다
  */
 
+import { InternalServerErrorException, ServiceUnavailableException } from "sonamu";
+
 import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
+import { SD } from "../../i18n/sd.generated";
 import { type AnthropicDispatcher } from "../../utils/providers/anthropic/anthropic-dispatcher";
 import { getAccessToken } from "../../utils/providers/common/credentials";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost";
@@ -22,8 +26,14 @@ import { strictify } from "../../utils/providers/common/strictifier";
 import { type OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
 import { type TokenSubsetA } from "../sonamu.generated";
 import { decideConvRouting, issueConvContext } from "./conv-routing";
-import { type QueryInput, type QueryOutput, type TokenStats } from "./qgrid.types";
-import { maskToken, ProcessError, QuotaError } from "./qgrid.types";
+import {
+  maskToken,
+  ProcessError,
+  type ProviderStartupState,
+  type QueryInput,
+  type QueryOutput,
+  type TokenStats,
+} from "./qgrid.types";
 import { type TokenSubscriber } from "./token-subscriber";
 import { applyToolCallEmulation } from "./tool-emulation";
 import { buildToolCallSchema } from "./tool-emulation-schema";
@@ -39,6 +49,34 @@ export class QgridDispatcherClass {
   openaiDispatcher: OpenAIDispatcher | null = null;
   anthropicDispatcher: AnthropicDispatcher | null = null;
 
+  /**
+   * provider 별 기동 상태. dispatcher 가 없는 이유를 구분하기 위해 필요하다 —
+   * HTTP 리스닝은 dispatcher 준비보다 먼저 열리므로(sonamu.config onStart),
+   * 그 사이 들어온 요청은 "잠시 후 되는" 상태와 "재시도해도 안 되는" 상태가 다르다.
+   *
+   * - `starting`: 워커 spawn 중. dev0 기준 25 워커 × 500ms 간격이라 1~2분 걸린다 → 재시도 가능
+   * - `ready`: 정상
+   * - `failed`: start() 가 예외로 끝남 → 재시도해도 같은 결과
+   */
+  startupState: Record<"openai" | "anthropic", ProviderStartupState> = {
+    openai: "starting",
+    anthropic: "starting",
+  };
+
+  /**
+   * dispatcher 가 준비되지 않았을 때 던질 예외를 만든다.
+   *
+   * 기동 중이면 503(+Retry-After) 으로 재시도 가능함을 알리고, 초기화가 실패로 끝났으면
+   * 500 으로 재시도가 무의미함을 알린다. 이전에는 둘 다 QuotaError 였는데, 쿼터 소진이
+   * 아닌 상태를 그렇게 표현하면 호출자가 토큰 문제로 오해하고 재시도 판단도 못 한다.
+   */
+  private notReadyError(provider: "openai" | "anthropic"): Error {
+    const label = provider === "openai" ? "OpenAI" : "Anthropic";
+    return this.startupState[provider] === "failed"
+      ? new InternalServerErrorException(SD("qgrid.dispatcherFailed")(label))
+      : new ServiceUnavailableException(SD("qgrid.dispatcherStarting")(label));
+  }
+
   countOf(name: string): number {
     return this.requestCounts.get(name) ?? 0;
   }
@@ -73,7 +111,7 @@ export class QgridDispatcherClass {
 
     // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher
     if (route.provider === "openai") {
-      if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+      if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
       const decision = decideConvRouting(input);
       const result = await this.openaiDispatcher.generate({
@@ -105,7 +143,7 @@ export class QgridDispatcherClass {
         answerKind,
       });
     } else if (route.provider === "anthropic") {
-      if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
+      if (!this.anthropicDispatcher) throw this.notReadyError("anthropic");
 
       const decision = decideConvRouting(input);
       const result = await this.anthropicDispatcher.generate({
@@ -142,7 +180,7 @@ export class QgridDispatcherClass {
     const answerKind = input.jsonSchema ? ("json" as const) : ("text" as const);
 
     if (route.provider === "openai") {
-      if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+      if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
       const decision = decideConvRouting(input);
       await this.openaiDispatcher.generateStream(
@@ -180,7 +218,7 @@ export class QgridDispatcherClass {
       );
       return;
     } else if (route.provider === "anthropic") {
-      if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
+      if (!this.anthropicDispatcher) throw this.notReadyError("anthropic");
 
       const decision = decideConvRouting(input);
       await this.anthropicDispatcher.generateStream(

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -13,6 +13,7 @@ import {
 } from "../../utils/providers/common/credentials";
 import { CallerSchemaValidationError } from "../../utils/providers/common/schema-validation";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model";
+import { type RequestLogListParams } from "../request-log/request-log.types";
 import { type TokenSubsetA } from "../sonamu.generated";
 import { TokenModel, type TokenUpdateFields } from "../token/token.model";
 import { TokenCredentials } from "../token/token.types";
@@ -24,6 +25,7 @@ import {
   fetchUsage,
   generatePKCE,
   refreshAccessToken,
+  RefreshFailedError,
 } from "./oauth";
 import {
   afterQuery,
@@ -45,6 +47,7 @@ import {
   type TokenStats,
   type UsageResponse,
 } from "./qgrid.types";
+import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death";
 import { ToolSchemaCompositionError } from "./tool-emulation-schema";
 
 const pendingStreams = new Map<string, QueryInput>();
@@ -197,6 +200,9 @@ function createHttpDisconnectHandle(): {
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
+// per-token refresh dedup — 회전 겹침으로 인한 사망 오판을 막는다.
+const inflightAnthropicRefresh = new Map<number, Promise<string>>();
+
 class QgridFrameClass extends BaseFrameClass {
   constructor() {
     super("Qgrid");
@@ -464,9 +470,11 @@ class QgridFrameClass extends BaseFrameClass {
     return QgridDispatcher.getStats();
   }
 
+  // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이
+  // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
-  async totalCost(tokenName?: string): Promise<{ usd: number }> {
-    return { usd: await RequestLogModel.totalCost({ token_name: tokenName }) };
+  async totalCost(params?: RequestLogListParams): Promise<{ usd: number }> {
+    return { usd: await RequestLogModel.totalCost(params) };
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
@@ -474,6 +482,11 @@ class QgridFrameClass extends BaseFrameClass {
     return { names: await RequestLogModel.distinctProjectNames() };
   }
 
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async modelNames(): Promise<{ names: string[] }> {
+    return { names: await RequestLogModel.distinctModelNames() };
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async addToken(
     provider: string,
@@ -601,29 +614,18 @@ class QgridFrameClass extends BaseFrameClass {
       pending.redirectUri,
     );
 
-    if (tokens.accountUuid) {
-      const oldEntries = await TokenModel.findByAccountIdentifier(
-        "A",
-        "anthropic",
-        tokens.accountUuid,
-      );
-      if (oldEntries.length > 0) {
-        await TokenModel.del(oldEntries.map((o) => o.id));
-      }
-    }
-
-    await TokenModel.save([
-      {
-        provider: "anthropic",
-        credentials: {
-          accessToken: tokens.accessToken,
-          refreshToken: tokens.refreshToken,
-          expiresAt: tokens.expiresAt ?? 0,
-          accountUuid: tokens.accountUuid ?? "",
-        },
-        name: pending.name,
+    await TokenModel.replaceByAccount("anthropic", tokens.accountUuid, {
+      provider: "anthropic",
+      credentials: {
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt ?? 0,
+        accountUuid: tokens.accountUuid ?? "",
       },
-    ]);
+      name: pending.name,
+    });
+
+    notifyTokenAdded(pending.name, "anthropic");
   }
 
   async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {
@@ -651,30 +653,19 @@ class QgridFrameClass extends BaseFrameClass {
     QgridDispatcher.openaiDispatcher
       .completeBrowserLogin()
       .then(async (creds) => {
-        if (creds.accountId) {
-          const oldEntries = await TokenModel.findByAccountIdentifier(
-            "A",
-            "openai",
-            creds.accountId,
-          );
-          if (oldEntries.length > 0) {
-            await TokenModel.del(oldEntries.map((o) => o.id));
-          }
-        }
-        await TokenModel.save([
-          {
-            provider: "openai",
-            credentials: {
-              accessToken: creds.accessToken,
-              refreshToken: creds.refreshToken,
-              idToken: creds.idToken,
-              accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,
-              accountId: creds.accountId,
-            },
-            name,
+        await TokenModel.replaceByAccount("openai", creds.accountId, {
+          provider: "openai",
+          credentials: {
+            accessToken: creds.accessToken,
+            refreshToken: creds.refreshToken,
+            idToken: creds.idToken,
+            accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,
+            accountId: creds.accountId,
           },
-        ]);
+          name,
+        });
         logger.info(`OpenAI token saved for ${name}`);
+        notifyTokenAdded(name, "openai");
       })
       .catch((e) => {
         logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);
@@ -754,11 +745,36 @@ class QgridFrameClass extends BaseFrameClass {
     return convertAnthropicUsage(raw);
   }
 
+  // 동시 refresh 가 회전을 겹치면 뒤늦은 호출이 이미 폐기된 refresh token 을 쓰게 되어
+  // 멀쩡한 토큰이 사망으로 오판된다. openai-refresh.ts 와 같은 per-token dedup 을 둔다.
   async refreshToken(token: TokenSubsetA): Promise<string> {
+    const inflight = inflightAnthropicRefresh.get(token.id);
+    if (inflight) return inflight;
+
+    const promise = this.doRefreshToken(token);
+    inflightAnthropicRefresh.set(token.id, promise);
+    try {
+      return await promise;
+    } finally {
+      inflightAnthropicRefresh.delete(token.id);
+    }
+  }
+
+  private async doRefreshToken(token: TokenSubsetA): Promise<string> {
     const creds = token.credentials;
     const rt = getRefreshToken(creds);
     if (!rt) throw new Error("No refresh token");
-    const refreshed = await refreshAccessToken(rt);
+
+    let refreshed;
+    try {
+      refreshed = await refreshAccessToken(rt);
+    } catch (e) {
+      if (e instanceof RefreshFailedError && e.isAuthDead) {
+        await deactivateAuthDeadToken(token, rt, `anthropic:${e.status}`);
+      }
+      throw e;
+    }
+
     const updated = TokenCredentials.parse({
       ...creds,
       accessToken: refreshed.accessToken,
@@ -778,10 +794,14 @@ class QgridFrameClass extends BaseFrameClass {
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async health(): Promise<HealthResponse> {
+    const providers = { ...QgridDispatcher.startupState };
     return {
       status: "ok",
       activeTokens: QgridDispatcher.tokens.size,
       subscriber: QgridDispatcher.subscriber?.status() ?? null,
+      // provider 별 라우팅이라 하나만 준비돼도 그 provider 요청은 처리된다.
+      ready: Object.values(providers).includes("ready"),
+      providers,
     };
   }
 }

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -306,10 +306,20 @@ export const SubscriberStatus = z.object({
 });
 export type SubscriberStatus = z.infer<typeof SubscriberStatus>;
 
+export const ProviderStartupState = z.enum(["starting", "ready", "failed"]);
+export type ProviderStartupState = z.infer<typeof ProviderStartupState>;
+
 export const HealthResponse = z.object({
   status: z.string(),
   activeTokens: z.number(),
   subscriber: SubscriberStatus.nullable(),
+  // HTTP 리스닝은 dispatcher 기동보다 먼저 열린다. 200 응답만으로는 요청을 처리할 수
+  // 있는지 알 수 없어 provider 별 준비 상태를 함께 노출한다.
+  ready: z.boolean(),
+  providers: z.object({
+    openai: ProviderStartupState,
+    anthropic: ProviderStartupState,
+  }),
 });
 export type HealthResponse = z.infer<typeof HealthResponse>;
 

package/bundle/src/application/qgrid/token-death.test.ts

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { SLACK_COLOR } from "../../utils/slack-notify";
+import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death";
+
+const { findOneMock, deactivateMock, notifySlackMock } = vi.hoisted(() => ({
+  findOneMock: vi.fn(),
+  deactivateMock: vi.fn(),
+  notifySlackMock: vi.fn(),
+}));
+
+vi.mock("../token/token.model", () => ({
+  TokenModel: { findOne: findOneMock, deactivateIfActive: deactivateMock },
+}));
+
+// SLACK_COLOR 는 상수라 가릴 이유가 없다 — 전송 함수만 스텁한다.
+vi.mock("../../utils/slack-notify", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../utils/slack-notify")>()),
+  notifySlack: notifySlackMock,
+}));
+
+const token = { id: 7, name: "anthropic/test-token", provider: "anthropic" };
+
+function storedRefreshToken(refreshToken: string) {
+  return {
+    id: 7,
+    provider: "anthropic",
+    credentials: { accessToken: "at", refreshToken, expiresAt: 0, accountUuid: "acc-1" },
+  };
+}
+
+describe("deactivateAuthDeadToken", () => {
+  afterEach(() => {
+    findOneMock.mockReset();
+    deactivateMock.mockReset();
+    notifySlackMock.mockReset();
+  });
+
+  it("deactivates and notifies when the failed attempt used the current refresh token", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
+
+    await expect(
+      deactivateAuthDeadToken(token, "rt-current", "anthropic:400"),
+    ).resolves.toBe(true);
+
+    expect(deactivateMock).toHaveBeenCalledWith(7);
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+    const notification = notifySlackMock.mock.calls[0]![0] as {
+      subject: string;
+      context: string;
+      color: string;
+    };
+    expect(notification.subject).toBe("anthropic/test-token");
+    expect(notification.context).toContain("anthropic:400");
+    expect(notification.color).toBe(SLACK_COLOR.bad);
+  });
+
+  it("skips deactivation when the refresh token rotated since the failed attempt", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-rotated"));
+
+    await expect(deactivateAuthDeadToken(token, "rt-stale", "anthropic:400")).resolves.toBe(false);
+
+    expect(deactivateMock).not.toHaveBeenCalled();
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("does not notify when another process won the deactivation race", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: false });
+
+    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
+      false,
+    );
+
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("alerts instead of deactivating when the dying token is the last active one", async () => {
+    // 알림 쿨다운이 모듈 수준 상태라 다른 테스트의 발송 기록에 가려질 수 있다.
+    vi.resetModules();
+    const { deactivateAuthDeadToken: freshDeactivate } = await import("./token-death");
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: true });
+
+    await expect(freshDeactivate(token, "rt-current", "anthropic:400")).resolves.toBe(false);
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+    const notification = notifySlackMock.mock.calls[0]![0] as { title: string; context: string };
+    expect(notification.title).toContain("마지막");
+    expect(notification.context).toContain("anthropic:400");
+  });
+
+  it("suppresses repeat last-active alerts for the same provider within the cooldown", async () => {
+    // 이 경로는 토큰을 비활성화하지 않아 상태 변화가 없다 — 억제가 없으면 요청마다 알림이 간다.
+    // 쿨다운은 모듈 수준 상태라 앞 테스트의 발송 기록이 남는다. 새로 불러 격리한다.
+    vi.resetModules();
+    const { deactivateAuthDeadToken: freshDeactivate } = await import("./token-death");
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: true });
+
+    await freshDeactivate(token, "rt-current", "anthropic:400");
+    await freshDeactivate(token, "rt-current", "anthropic:400");
+    await freshDeactivate(token, "rt-current", "anthropic:401");
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("does nothing when the token no longer exists", async () => {
+    findOneMock.mockResolvedValue(undefined);
+
+    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
+      false,
+    );
+
+    expect(deactivateMock).not.toHaveBeenCalled();
+  });
+
+  it("never puts the raw provider error body in the notification", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
+
+    await deactivateAuthDeadToken(token, "rt-current", "anthropic:400");
+
+    // 필드가 늘어도 새는 곳이 생기지 않도록 페이로드 전체를 훑는다.
+    const payload = JSON.stringify(notifySlackMock.mock.calls[0]![0]);
+    expect(payload).not.toContain("sk-ant");
+    expect(payload).not.toContain("@");
+  });
+});
+
+describe("notifyTokenAdded", () => {
+  afterEach(() => {
+    notifySlackMock.mockReset();
+  });
+
+  it("sends one added notification naming the token and provider", () => {
+    notifyTokenAdded("anthropic/test-token", "anthropic");
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+    const notification = notifySlackMock.mock.calls[0]![0] as {
+      subject: string;
+      context: string;
+      color: string;
+    };
+    expect(notification.subject).toBe("anthropic/test-token");
+    expect(notification.context).toContain("anthropic");
+    expect(notification.color).toBe(SLACK_COLOR.good);
+  });
+});