@cartanova/qgrid-cli 2.6.2 → 2.6.5

package/bundle/dist/sonamu.config.js

@@ -1,5 +1,6 @@
 import { monitLogSink } from "./application/monit/log-buffer.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
+import { startExpiredTokenDigest, stopExpiredTokenDigest } from "./application/qgrid/expired-token-digest.js";
 import { QgridFrame } from "./application/qgrid/qgrid.frame.js";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber.js";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup.js";
@@ -146,16 +147,21 @@ var sonamu_config_default = defineConfig({
 					const openaiDispatcher = new OpenAIDispatcher();
 					await openaiDispatcher.start();
 					QgridDispatcher.openaiDispatcher = openaiDispatcher;
+					QgridDispatcher.startupState.openai = "ready";
 				} catch (e) {
+					QgridDispatcher.startupState.openai = "failed";
 					log.warn(`openai dispatcher failed: ${e.message}`);
 				}
 				try {
 					const anthropicDispatcher = new AnthropicDispatcher();
 					await anthropicDispatcher.start();
 					QgridDispatcher.anthropicDispatcher = anthropicDispatcher;
+					QgridDispatcher.startupState.anthropic = "ready";
 				} catch (e) {
+					QgridDispatcher.startupState.anthropic = "failed";
 					log.warn(`anthropic dispatcher failed: ${e.message}`);
 				}
+				startExpiredTokenDigest();
 				const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
 				const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
 				const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
@@ -166,6 +172,7 @@ var sonamu_config_default = defineConfig({
 			},
 			onShutdown: async () => {
 				const log = getLogger(["qgrid", "startup"]);
+				stopExpiredTokenDigest();
 				if (QgridDispatcher.openaiDispatcher) await QgridDispatcher.openaiDispatcher.stop();
 				if (QgridDispatcher.anthropicDispatcher) await QgridDispatcher.anthropicDispatcher.stop();
 				if (QgridDispatcher.subscriber) await QgridDispatcher.subscriber.stop();
@@ -180,4 +187,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport {\n  startExpiredTokenDigest,\n  stopExpiredTokenDigest,\n} from \"./application/qgrid/expired-token-digest\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        // 기동 상태를 남긴다 — HTTP 는 이미 열려 있어서, 준비 전 요청이 \"잠시 후 되는지\"\n        // \"재시도해도 안 되는지\"를 구분해 응답해야 한다(503 vs 500).\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n          QgridDispatcher.startupState.openai = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.openai = \"failed\";\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n          QgridDispatcher.startupState.anthropic = \"ready\";\n        } catch (e) {\n          QgridDispatcher.startupState.anthropic = \"failed\";\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        startExpiredTokenDigest();\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        stopExpiredTokenDigest();\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}

package/bundle/dist/utils/slack-notify.js

@@ -45,8 +45,8 @@ async function notifySlack(notification) {
 			},
 			body: JSON.stringify({
 				channel,
-				text: subject ? `${title} — ${subject}` : title,
 				attachments: [{
+					fallback: subject ? `${title} — ${subject}` : title,
 					...color ? { color } : {},
 					blocks
 				}]
@@ -62,4 +62,4 @@ async function notifySlack(notification) {
 //#endregion
 export { SLACK_COLOR, notifySlack };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhY2stbm90aWZ5LmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9zbGFjay1ub3RpZnkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTbGFjayDslYzrprwgKGNoYXQucG9zdE1lc3NhZ2UpLlxuICpcbiAqIGZhaWwtb3BlbjogZW52IOuvuOyEpOygleydtOuptCDsobDsmqntnoggbm8tb3Ag7J206rOgLCDsoITshqEg7Iuk7Yyo64qUIHdhcm4g66Gc6re466Gc66eMIOuCqOq4tOuLpC5cbiAqIOyVjOumvCDqsr3roZzqsIAg7Yag7YGwIOudvOyasO2MheydtOuCmCDsmKTrpZgg7KCE7YyM66W8IOyngOyXsMK37LCo64uo7ZW07ISc64qUIOyViCDrkJzri6QuXG4gKi9cbmltcG9ydCB7IGdldExvZ2dlciB9IGZyb20gXCJAbG9ndGFwZS9sb2d0YXBlXCI7XG5cbmNvbnN0IGxvZ2dlciA9IGdldExvZ2dlcihbXCJxZ3JpZFwiLCBcInNsYWNrXCJdKTtcblxuY29uc3QgU0xBQ0tfUE9TVF9NRVNTQUdFX1VSTCA9IFwiaHR0cHM6Ly9zbGFjay5jb20vYXBpL2NoYXQucG9zdE1lc3NhZ2VcIjtcbmNvbnN0IFNMQUNLX1RJTUVPVVRfTVMgPSA1XzAwMDtcblxuLyoqIOyDge2DnOulvCDsg4nsnLzroZwg66i87KCAIOydve2eiOqyjCDtlZjripQgYXR0YWNobWVudCDsg4nsg4Eg67CULiAqL1xuZXhwb3J0IGNvbnN0IFNMQUNLX0NPTE9SID0ge1xuICBnb29kOiBcIiMyZWI4ODZcIixcbiAgYmFkOiBcIiNlMDFlNWFcIixcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCB0eXBlIFNsYWNrTm90aWZpY2F0aW9uID0ge1xuICAvKiog7ZWcIOykhCDsoJzrqqkuIOustOyKqCDsnbzsnbQg7J287Ja064Ks64qU7KeA66eMIOuLtOuKlOuLpC4gKi9cbiAgdGl0bGU6IHN0cmluZztcbiAgLyoqIOygnOuqqSDsmIYg7L2U65OcIOyKpO2DgOydvOuhnCDrtpnripQg64yA7IOBIOyLneuzhOyekC4gKi9cbiAgc3ViamVjdD86IHN0cmluZztcbiAgLyoqIOygnOuqqSDslYTrnpgg7J6R7J2AIOq4gOyUqOuhnCDrgrTroKTqsIDripQg67aA6rCAIOygleuztCDigJQg7J297KeAIOyViuyVhOuPhCDrkJjripQg6rKD65OkLiAqL1xuICBjb250ZXh0Pzogc3RyaW5nO1xuICBjb2xvcj86ICh0eXBlb2YgU0xBQ0tfQ09MT1IpW2tleW9mIHR5cGVvZiBTTEFDS19DT0xPUl07XG59O1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbm90aWZ5U2xhY2sobm90aWZpY2F0aW9uOiBTbGFja05vdGlmaWNhdGlvbik6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBib3RUb2tlbiA9IHByb2Nlc3MuZW52LlNMQUNLX0JPVF9UT0tFTjtcbiAgY29uc3QgY2hhbm5lbCA9IHByb2Nlc3MuZW52LlNMQUNLX0NIQU5ORUxfSUQ7XG4gIGNvbnN0IHsgdGl0bGUsIHN1YmplY3QsIGNvbnRleHQsIGNvbG9yIH0gPSBub3RpZmljYXRpb247XG4gIGlmICghYm90VG9rZW4gfHwgIWNoYW5uZWwpIHtcbiAgICBsb2dnZXIuZGVidWcoYHNsYWNrIG5vdCBjb25maWd1cmVkLCBza2lwcGluZyBub3RpZmljYXRpb246ICR7dGl0bGV9ICR7c3ViamVjdCA/PyBcIlwifWApO1xuICAgIHJldHVybjtcbiAgfVxuXG4gIGNvbnN0IGJsb2NrczogdW5rbm93bltdID0gW1xuICAgIHtcbiAgICAgIHR5cGU6IFwic2VjdGlvblwiLFxuICAgICAgdGV4dDogeyB0eXBlOiBcIm1ya2R3blwiLCB0ZXh0OiBzdWJqZWN0ID8gYCoke3RpdGxlfSogIFxcYCR7c3ViamVjdH1cXGBgIDogYCoke3RpdGxlfSpgIH0sXG4gICAgfSxcbiAgXTtcbiAgaWYgKGNvbnRleHQpIHtcbiAgICBibG9ja3MucHVzaCh7IHR5cGU6IFwiY29udGV4dFwiLCBlbGVtZW50czogW3sgdHlwZTogXCJtcmtkd25cIiwgdGV4dDogY29udGV4dCB9XSB9KTtcbiAgfVxuXG4gIHRyeSB7XG4gICAgY29uc3QgcmVzID0gYXdhaXQgZmV0Y2goU0xBQ0tfUE9TVF9NRVNTQUdFX1VSTCwge1xuICAgICAgbWV0aG9kOiBcIlBPU1RcIixcbiAgICAgIGhlYWRlcnM6IHtcbiAgICAgICAgXCJDb250ZW50LVR5cGVcIjogXCJhcHBsaWNhdGlvbi9qc29uOyBjaGFyc2V0PXV0Zi04XCIsXG4gICAgICAgIEF1dGhvcml6YXRpb246IGBCZWFyZXIgJHtib3RUb2tlbn1gLFxuICAgICAgfSxcbiAgICAgIGJvZHk6IEpTT04uc3RyaW5naWZ5KHtcbiAgICAgICAgY2hhbm5lbCxcbiAgICAgICAgLy8g7JWM66a8IOuvuOumrOuztOq4sMK37KCR6re87ISx7JqpIOuMgOyytCDthY3siqTtirguIGJsb2NrcyDrp4wg67O064K066m0IO2RuOyLnCDslYzrprzsnbQg67mI7Lm47Jy866GcIOucrOuLpC5cbiAgICAgICAgdGV4dDogc3ViamVjdCA/IGAke3RpdGxlfSDigJQgJHtzdWJqZWN0fWAgOiB0aXRsZSxcbiAgICAgICAgYXR0YWNobWVudHM6IFt7IC4uLihjb2xvciA/IHsgY29sb3IgfSA6IHt9KSwgYmxvY2tzIH1dLFxuICAgICAgfSksXG4gICAgICBzaWduYWw6IEFib3J0U2lnbmFsLnRpbWVvdXQoU0xBQ0tfVElNRU9VVF9NUyksXG4gICAgfSk7XG5cbiAgICAvLyBib3Qg66+47LSI64yAKG5vdF9pbl9jaGFubmVsKcK37J6Y66q765CcIOyxhOuEkCDrk7Eg6rCA7J6lIO2dlO2VnCDsmKTshKTsoJXsnYAgSFRUUCAyMDAgKyBvazpmYWxzZSDroZwg7Jio64ukLlxuICAgIC8vIHN0YXR1cyDrp4wg67O066m0IOyhsOyaqe2eiCDshLHqs7Ug7LKY66as64+8IOyVjOumvOydtCDthrXsp7jroZwg7IKs65287KeE64ukLlxuICAgIGNvbnN0IGJvZHkgPSAoYXdhaXQgcmVzLmpzb24oKS5jYXRjaCgoKSA9PiBudWxsKSkgYXMgeyBvaz86IGJvb2xlYW47IGVycm9yPzogc3RyaW5nIH0gfCBudWxsO1xuICAgIGlmICghYm9keT8ub2spIHtcbiAgICAgIGxvZ2dlci53YXJuKGBzbGFjayBub3RpZmljYXRpb24gcmVqZWN0ZWQ6ICR7Ym9keT8uZXJyb3IgPz8gYGh0dHAgJHtyZXMuc3RhdHVzfWB9YCk7XG4gICAgfVxuICB9IGNhdGNoIChlKSB7XG4gICAgbG9nZ2VyLndhcm4oYHNsYWNrIG5vdGlmaWNhdGlvbiBmYWlsZWQ6ICR7KGUgYXMgRXJyb3IpLm1lc3NhZ2V9YCk7XG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFRQSxNQUFNLFNBQVMsVUFBVSxDQUFDLFNBQVMsT0FBTyxDQUFDO0FBRTNDLE1BQU0seUJBQXlCO0FBQy9CLE1BQU0sbUJBQW1COztBQUd6QixNQUFhLGNBQWM7Q0FDekIsTUFBTTtDQUNOLEtBQUs7QUFDUDtBQVlBLGVBQXNCLFlBQVksY0FBZ0Q7Q0FDaEYsTUFBTSxXQUFXLFFBQVEsSUFBSTtDQUM3QixNQUFNLFVBQVUsUUFBUSxJQUFJO0NBQzVCLE1BQU0sRUFBRSxPQUFPLFNBQVMsU0FBUyxVQUFVO0NBQzNDLElBQUksQ0FBQyxZQUFZLENBQUMsU0FBUztFQUN6QixPQUFPLE1BQU0sZ0RBQWdELE1BQU0sR0FBRyxXQUFXLElBQUk7RUFDckY7Q0FDRjtDQUVBLE1BQU0sU0FBb0IsQ0FDeEI7RUFDRSxNQUFNO0VBQ04sTUFBTTtHQUFFLE1BQU07R0FBVSxNQUFNLFVBQVUsSUFBSSxNQUFNLE9BQU8sUUFBUSxNQUFNLElBQUksTUFBTTtFQUFHO0NBQ3RGLENBQ0Y7Q0FDQSxJQUFJLFNBQ0YsT0FBTyxLQUFLO0VBQUUsTUFBTTtFQUFXLFVBQVUsQ0FBQztHQUFFLE1BQU07R0FBVSxNQUFNO0VBQVEsQ0FBQztDQUFFLENBQUM7Q0FHaEYsSUFBSTtFQUNGLE1BQU0sTUFBTSxNQUFNLE1BQU0sd0JBQXdCO0dBQzlDLFFBQVE7R0FDUixTQUFTO0lBQ1AsZ0JBQWdCO0lBQ2hCLGVBQWUsVUFBVTtHQUMzQjtHQUNBLE1BQU0sS0FBSyxVQUFVO0lBQ25CO0lBRUEsTUFBTSxVQUFVLEdBQUcsTUFBTSxLQUFLLFlBQVk7SUFDMUMsYUFBYSxDQUFDO0tBQUUsR0FBSSxRQUFRLEVBQUUsTUFBTSxJQUFJLENBQUM7S0FBSTtJQUFPLENBQUM7R0FDdkQsQ0FBQztHQUNELFFBQVEsWUFBWSxRQUFRLGdCQUFnQjtFQUM5QyxDQUFDO0VBSUQsTUFBTSxPQUFRLE1BQU0sSUFBSSxLQUFLLENBQUMsQ0FBQyxZQUFZLElBQUk7RUFDL0MsSUFBSSxDQUFDLE1BQU0sSUFDVCxPQUFPLEtBQUssZ0NBQWdDLE1BQU0sU0FBUyxRQUFRLElBQUksVUFBVTtDQUVyRixTQUFTLEdBQUc7RUFDVixPQUFPLEtBQUssOEJBQStCLEVBQVksU0FBUztDQUNsRTtBQUNGIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/src/application/qgrid/expired-token-digest.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+
+import { buildDigestContext } from "./expired-token-digest";
+
+const userMap = new Map([
+  ["yds", "U09NAJUQSFQ"],
+  ["haze", "U09N96NHZB7"],
+]);
+
+describe("buildDigestContext", () => {
+  it("매핑된 토큰은 멘션으로 개인에게 꽂는다", () => {
+    const text = buildDigestContext([{ name: "anthropic/yds", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09NAJUQSFQ> anthropic");
+  });
+
+  it("공용 계정처럼 매핑이 없으면 멘션 없이 이름만 남긴다", () => {
+    const text = buildDigestContext(
+      [{ name: "anthropic/dev-common", provider: "anthropic" }],
+      userMap,
+    );
+
+    expect(text).toBe("anthropic/dev-common (anthropic)");
+  });
+
+  it("같은 사람의 provider 별 토큰을 각각 줄로 나열한다", () => {
+    const text = buildDigestContext(
+      [
+        { name: "anthropic/yds", provider: "anthropic" },
+        { name: "openai/yds", provider: "openai" },
+      ],
+      userMap,
+    );
+
+    expect(text.split("\n")).toEqual(["<@U09NAJUQSFQ> anthropic", "<@U09NAJUQSFQ> openai"]);
+  });
+
+  it("provider prefix 없이 저장된 이름도 매핑한다", () => {
+    const text = buildDigestContext([{ name: "haze", provider: "anthropic" }], userMap);
+
+    expect(text).toBe("<@U09N96NHZB7> anthropic");
+  });
+
+  it("이름이 없는 토큰도 줄을 잃지 않는다", () => {
+    const text = buildDigestContext([{ name: null, provider: "openai" }], userMap);
+
+    expect(text).toBe("unnamed (openai)");
+  });
+});

package/bundle/src/application/qgrid/expired-token-digest.ts

@@ -0,0 +1,93 @@
+/**
+ * 비활성 토큰 주기 알림.
+ *
+ * 사망 순간의 단발 알림(`token-death.ts`)은 그 시점에 채널을 보지 않으면 놓친다. 재로그인은
+ * 사람이 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 남아 있는 비활성
+ * 토큰을 주기적으로 다시 알리고, 소유자를 멘션해 개인에게 꽂는다.
+ *
+ * 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+ */
+import { getLogger } from "@logtape/logtape";
+
+import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { TokenModel } from "../token/token.model";
+
+const logger = getLogger(["qgrid", "expired-digest"]);
+
+const MINUTE_MS = 60_000;
+
+/**
+ * `토큰명:SlackUserId` 목록. 공용 계정(bysuco, dev-common 등)은 넣지 않는다 — 매핑이 없으면
+ * 멘션 없이 이름만 나가고, 그게 맞는 동작이다.
+ *
+ * Slack 표시 이름과 토큰명이 자주 어긋나(haze→haze.lee, byeongjun→potados) 자동 매칭은
+ * 조용히 실패한다. 멘션이 빠지면 알림의 목적 자체가 사라지므로 명시 매핑만 쓴다.
+ */
+function parseUserMap(raw: string | undefined): Map<string, string> {
+  const map = new Map<string, string>();
+  if (!raw) return map;
+
+  for (const entry of raw.split(",")) {
+    const [name, userId] = entry.split(":").map((s) => s.trim());
+    if (name && userId) map.set(name, userId);
+  }
+  return map;
+}
+
+/** `anthropic/yds` → `yds`. provider prefix 없이 저장된 이름도 그대로 받는다. */
+function ownerOf(tokenName: string | null): string {
+  if (!tokenName) return "";
+  const slash = tokenName.indexOf("/");
+  return slash === -1 ? tokenName : tokenName.slice(slash + 1);
+}
+
+export function buildDigestContext(
+  tokens: { name: string | null; provider: string }[],
+  userMap: Map<string, string>,
+): string {
+  return tokens
+    .map((token) => {
+      const userId = userMap.get(ownerOf(token.name));
+      const label = token.name ?? "unnamed";
+      // 멘션이 있으면 이름 대신 멘션을 쓴다 — 둘 다 쓰면 같은 말이 두 번 나온다.
+      return userId ? `<@${userId}> ${token.provider}` : `${label} (${token.provider})`;
+    })
+    .join("\n");
+}
+
+async function sendDigest(userMap: Map<string, string>): Promise<void> {
+  const inactive = await TokenModel.findInactive("A");
+  if (inactive.length === 0) return;
+
+  await notifySlack({
+    title: `재로그인 필요 ${inactive.length}건`,
+    context: buildDigestContext(inactive, userMap),
+    color: SLACK_COLOR.bad,
+  });
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+ *
+ * 인스턴스가 여러 개면 각자 보낸다. 사망 알림과 달리 상태 변화가 없어 DB 로 억제할 수 없고,
+ * 다이제스트는 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+ */
+export function startExpiredTokenDigest(): void {
+  const minutes = Number(process.env.SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES ?? 0);
+  if (!Number.isFinite(minutes) || minutes <= 0) return;
+
+  const userMap = parseUserMap(process.env.SLACK_USER_MAP);
+  logger.info(`expired token digest every ${minutes}m (${userMap.size} user mappings)`);
+
+  timer = setInterval(() => {
+    sendDigest(userMap).catch((e) => logger.warn(`digest failed: ${(e as Error).message}`));
+  }, minutes * MINUTE_MS);
+}
+
+export function stopExpiredTokenDigest(): void {
+  if (!timer) return;
+  clearInterval(timer);
+  timer = null;
+}

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

@@ -43,14 +43,11 @@ vi.mock("../token/token.model", () => ({
       accountId: string | undefined,
       saveParams: unknown,
     ) => {
-      let isNew = false;
       if (accountId) {
         const olds = (await findByAccountMock()) as unknown as { id: number; active: boolean }[];
         if (olds.length > 0) await tokenDelMock();
-        else isNew = true;
       }
       await (tokenSaveMock as unknown as (rows: unknown[]) => Promise<number[]>)([saveParams]);
-      return { isNew };
     },
   },
 }));

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

@@ -482,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,
@@ -609,7 +614,7 @@ class QgridFrameClass extends BaseFrameClass {
       pending.redirectUri,
     );
 
-    const { isNew } = await TokenModel.replaceByAccount("anthropic", tokens.accountUuid, {
+    await TokenModel.replaceByAccount("anthropic", tokens.accountUuid, {
       provider: "anthropic",
       credentials: {
         accessToken: tokens.accessToken,
@@ -620,7 +625,7 @@ class QgridFrameClass extends BaseFrameClass {
       name: pending.name,
     });
 
-    if (isNew) notifyTokenAdded(pending.name, "anthropic");
+    notifyTokenAdded(pending.name, "anthropic");
   }
 
   async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {
@@ -648,7 +653,7 @@ class QgridFrameClass extends BaseFrameClass {
     QgridDispatcher.openaiDispatcher
       .completeBrowserLogin()
       .then(async (creds) => {
-        const { isNew } = await TokenModel.replaceByAccount("openai", creds.accountId, {
+        await TokenModel.replaceByAccount("openai", creds.accountId, {
           provider: "openai",
           credentials: {
             accessToken: creds.accessToken,
@@ -660,7 +665,7 @@ class QgridFrameClass extends BaseFrameClass {
           name,
         });
         logger.info(`OpenAI token saved for ${name}`);
-        if (isNew) notifyTokenAdded(name, "openai");
+        notifyTokenAdded(name, "openai");
       })
       .catch((e) => {
         logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);
@@ -789,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

@@ -38,7 +38,7 @@ describe("deactivateAuthDeadToken", () => {
 
   it("deactivates and notifies when the failed attempt used the current refresh token", async () => {
     findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue(true);
+    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
 
     await expect(
       deactivateAuthDeadToken(token, "rt-current", "anthropic:400"),
@@ -67,7 +67,7 @@ describe("deactivateAuthDeadToken", () => {
 
   it("does not notify when another process won the deactivation race", async () => {
     findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue(false);
+    deactivateMock.mockResolvedValue({ deactivated: false, keptAsLastActive: false });
 
     await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
       false,
@@ -76,6 +76,36 @@ describe("deactivateAuthDeadToken", () => {
     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);
 
@@ -88,7 +118,7 @@ describe("deactivateAuthDeadToken", () => {
 
   it("never puts the raw provider error body in the notification", async () => {
     findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
-    deactivateMock.mockResolvedValue(true);
+    deactivateMock.mockResolvedValue({ deactivated: true, keptAsLastActive: false });
 
     await deactivateAuthDeadToken(token, "rt-current", "anthropic:400");
 

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

@@ -42,8 +42,11 @@ export async function deactivateAuthDeadToken(
     return false;
   }
 
-  const deactivated = await TokenModel.deactivateIfActive(token.id);
-  if (!deactivated) return false;
+  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);
+  if (!deactivated) {
+    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);
+    return false;
+  }
 
   logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
   void notifySlack({
@@ -55,7 +58,33 @@ export async function deactivateAuthDeadToken(
   return true;
 }
 
-/** 처음 보는 계정이 등록됐을 때. 재로그인(기존 토큰 교체)은 알리지 않는다. */
+/**
+ * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.
+ *
+ * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해
+ * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔
+ * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.
+ */
+const LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;
+const lastActiveAlertAt = new Map<string, number>();
+
+function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {
+  const now = Date.now();
+  const previous = lastActiveAlertAt.get(token.provider);
+  if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;
+  lastActiveAlertAt.set(token.provider, now);
+
+  void notifySlack({
+    title: "마지막 토큰 사망",
+    subject: token.name,
+    context:
+      `${token.provider} · ${reasonCode} · 풀이 비지 않도록 유지 중입니다. ` +
+      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
+    color: SLACK_COLOR.bad,
+  });
+}
+
+/** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */
 export function notifyTokenAdded(name: string, provider: string): void {
   logger.info(`token added: ${name} (${provider})`);
   void notifySlack({