@genee/omp-opsx-addon 0.1.0 → 0.3.0

package/index.ts

@@ -101,8 +101,7 @@ function handleSubagentEvent(payload: unknown, primarySessionId: string): void {
         // This prevents cross-stream contamination while keeping global totals intact
         const subagentStreamKey = `${primarySessionId}:subagent:${p.id}`;
 
-        // Record usage with subagent-specific stream key (NO setSessionId call)
-        sessionUsageRecorder.record(provider, usage, subagentStreamKey);
+        sessionUsageRecorder.record(canonicalizeProvider(provider), usage, subagentStreamKey);
     } catch (err) {
         // Silently fail to avoid breaking the plugin
         console.error('Failed to handle subagent event:', err);
@@ -121,6 +120,8 @@ import { scoreModelWithProvider } from './lib/model-tiers.js';
 import { DIRECT_FETCHERS } from './lib/direct-fetchers.js';
 import { createUsageWidget } from './lib/usage-widget.js';
 import { renderUsageReports, type ConsumptionTrack } from './lib/usage-render.js';
+import { markExhausted, markAvailable, getExhaustedProviders } from './lib/provider-status.js';
+import { scheduleStatusProbes } from './lib/status-probe.js';
 import {
     startSharedPoller,
     getUnconfirmedProviders,
@@ -692,11 +693,30 @@ export default (pi: ExtensionAPI) => {
                 const reports = state?.reports ?? [];
                 let loggedIn: string[] = [];
                 let authAvailable = false;
+                // Three-way dedup union of the "logged in" universe:
+                // 1. providers derived from modelRegistry.getAvailable() — models
+                //    whose provider has auth and is not disabled (covers models.yml
+                //    config-override apiKeys that authStorage.list() never sees);
+                // 2. authStorage.list() — SQLite credential keys (incl. non-catalog
+                //    providers getAvailable() doesn't surface);
+                // 3. locally-detectable direct-fetcher credentials.
+                // All ids canonicalized (lowercase) before dedup so one provider
+                // never surfaces as two columns / tracks.
+                try {
+                    if (typeof ctx.modelRegistry?.getAvailable === 'function') {
+                        const available = ctx.modelRegistry.getAvailable();
+                        authAvailable = true;
+                        loggedIn = [...new Set(available.map((m) => canonicalizeProvider(m.provider)).filter(Boolean))];
+                    }
+                } catch {
+                    /* modelRegistry unavailable → fall back to auth.list() + detectable */
+                }
                 try {
                     if (auth?.list) {
                         authAvailable = true;
                         const list = auth.list();
-                        loggedIn = Array.isArray(list) ? list : [];
+                        const ids = Array.isArray(list) ? list : [];
+                        loggedIn = [...new Set([...loggedIn, ...ids.map(canonicalizeProvider)])];
                     }
                 } catch {
                     /* treat authStorage as unavailable */
@@ -759,13 +779,13 @@ export default (pi: ExtensionAPI) => {
                     consumptionTracks.set(p, { samples: getConsumptionSamples(p) });
                 }
                 if (ctx.hasUI) {
-                    ctx.ui.setWidget(key, createUsageWidget(reports, placeholderIds, loadingProviders, consumptionTracks, usageEstimates), {
+                    ctx.ui.setWidget(key, createUsageWidget(reports, placeholderIds, loadingProviders, consumptionTracks, usageEstimates, getExhaustedProviders()), {
                         placement: 'belowEditor',
                     });
                 } else {
                     if (ctx.ui) {
                         const cols = (process.stdout.columns ?? 120) - 3;
-                        const lines = renderUsageReports(reports, cols, undefined, placeholderIds, loadingProviders, consumptionTracks, usageEstimates);
+                        const lines = renderUsageReports(reports, cols, undefined, placeholderIds, loadingProviders, consumptionTracks, usageEstimates, getExhaustedProviders());
                         ctx.ui.setWidget(key, lines.length > 0 ? lines : undefined, { placement: 'belowEditor' });
                     }
                 }
@@ -775,9 +795,37 @@ export default (pi: ExtensionAPI) => {
             // provider's aggregated consumption RATE (all sessions, main +
             // subagent via cache backflow), and re-renders the widget. It never
             // recomputes a selection, never applies overrides, never setModel.
+            const cfg = buildEffectiveConfig();
             const onTick = () => {
+                // Fire-and-forget status probe: do not block the tick.
+                const { placeholderIds, active } = resolveActiveProviders();
+                let models: { id: string; provider: string; baseUrl?: string }[] = [];
+                try {
+                    if (ctx.modelRegistry && typeof ctx.modelRegistry.getAvailable === 'function') {
+                        models = ctx.modelRegistry.getAvailable() as { id: string; provider: string; baseUrl?: string }[];
+                    }
+                } catch {
+                    if (ctx.modelRegistry && typeof ctx.modelRegistry.getAll === 'function') {
+                        try {
+                            models = ctx.modelRegistry.getAll() as { id: string; provider: string; baseUrl?: string }[];
+                        } catch {
+                            models = [];
+                        }
+                    }
+                }
+                void scheduleStatusProbes({
+                    placeholderIds,
+                    models,
+                    getApiKey,
+                    config: {
+                        enabled: cfg.status_probe_enabled,
+                        ttlMs: cfg.probe_ttl_ms,
+                        timeoutMs: cfg.probe_timeout_ms,
+                        excluded: cfg.excluded_providers,
+                    },
+                }).then((written) => { if (written > 0) render(); }).catch(() => {});
+
                 sessionUsageRecorder.flush();
-                const { active } = resolveActiveProviders();
                 // Waveform source = per-second consumption sequence (timestamped
                 // deltas aggregated across sessions). Sample EVERY elapsed second
                 // for EVERY active provider — zeros when a second had no
@@ -803,7 +851,6 @@ export default (pi: ExtensionAPI) => {
                 lastSampledSec = lastSec;
                 render();
             };
-            const cfg = buildEffectiveConfig();
             await startSharedPoller(auth, DIRECT_FETCHERS, getApiKey, {
                 onTick: claimsOwnership ? onTick : undefined,
                 ownsUi,
@@ -868,7 +915,7 @@ export default (pi: ExtensionAPI) => {
             const ev = event.assistantMessageEvent;
             if ('partial' in ev) {
                 const usage = assistantUsageOf(ev.partial);
-                if (usage) sessionUsageRecorder.record(usage.provider, usage.usage);
+                if (usage) sessionUsageRecorder.record(canonicalizeProvider(usage.provider), usage.usage);
             }
         } catch {
             /* usage recording is best-effort; stay silent */
@@ -879,7 +926,7 @@ export default (pi: ExtensionAPI) => {
     pi.on('message_end', async (event) => {
         try {
             const usage = assistantUsageOf(event.message);
-            if (usage) sessionUsageRecorder.record(usage.provider, usage.usage);
+            if (usage) sessionUsageRecorder.record(canonicalizeProvider(usage.provider), usage.usage);
         } catch {
             /* usage recording is best-effort; stay silent */
         }
@@ -973,6 +1020,10 @@ export default (pi: ExtensionAPI) => {
         const getApiKey = ctx.modelRegistry?.getApiKeyForProvider
             ? (provider: string) => ctx.modelRegistry.getApiKeyForProvider(provider)
             : undefined;
+        // 429/403 is the only observable exhaustion evidence for providers
+        // without a usage fetcher — record it in the process-local binary status
+        // so the placeholder column reads 耗尽 (see lib/provider-status.ts).
+        markExhausted(canonical);
         // Force-refresh just this provider (bypassing the 10s floor) so the
         // diagnosis reflects current quota.
         if (auth) await pokeProvider(auth, DIRECT_FETCHERS, getApiKey, { providers: [canonical], force: true });
@@ -989,6 +1040,10 @@ export default (pi: ExtensionAPI) => {
                 await diagnoseProviderError(ctx, `HTTP ${event.status}`, '429');
             } else if (event.status === 403) {
                 await diagnoseProviderError(ctx, `HTTP ${event.status}`, '403');
+            } else if (event.status >= 200 && event.status < 300) {
+                // Strict 2xx restores the provider's binary status. 5xx / other
+                // 4xx are NOT recovery evidence and must not clear exhaustion.
+                if (ctx.model) markAvailable(canonicalizeProvider(ctx.model.provider));
             }
         } catch (e) {
             warn(`[omp-opsx-addon] after_provider_response error: ${e}`);

package/lib/agent-defs.ts

@@ -14,6 +14,12 @@ tools: read, bash, glob, grep${model ? `\nmodel: ${model}` : ''}
 1. 从 prompt 或上下文确定要审查的变更
 2. 读取 proposal、design 和 tasks 文件
 3. 运行 \`git diff HEAD~1\` 或 \`git diff --stat\` 查看改动
+## scratchpad.md 共享缓存
+- 审查前 MUST 先读 \`openspec/changes/<name>/scratchpad.md\`（若存在），只读不改写（工具集无 write/edit）。
+- 以「调研与设计」+「实现探索」两区累计的涉及文件 \`path:line\` 集合为代码审查与增量验证范围：Tier 1（typecheck/lint）与 Tier 3（E2E，如适用）聚焦涉及文件改动面；Tier 2 冒烟套件仍全量执行项目现有测试套件。
+- 无 scratchpad.md 时回退：从 proposal/design/tasks 确定审查范围。
+- 识别 \`- [R<n> coder] supersede:\` 条目：以紧随其后的新结论为权威，旧 \`path:line\` 不再作为验证范围；只读不改写。
+- 发现 scratchpad.md 结论与代码现状不符时，作为 P0/P1 审查发现发回，不直接改写。
 
 ## 审查维度
 1. **规范遵循**：是否精确实现了 proposal/design/tasks 定义的内容？有无缺失或偏离？
@@ -73,6 +79,11 @@ tools: read, bash, glob, grep${model ? `\nmodel: ${model}` : ''}
 ## 启动
 1. 从 prompt 或上下文确定要审查的提案名称
 2. 读取 proposal.md、design.md（如果存在）
+## scratchpad.md 共享缓存
+- 审查前 MUST 先读 \`openspec/changes/<name>/scratchpad.md\`（若存在），复用其中调研结论与涉及文件，避免重复 read/grep。
+- 只读，不改写 scratchpad.md；你的工具集不含 write/edit，物理上无法写入。
+- 识别 \`- [R<n> coder] supersede:\` 条目：以紧随其后的新结论为权威，旧结论不再作为调研依据；只读不改写。
+- 发现的 P0/P1 与关注点写入审查报告，由主 agent 中转回流，不直接写 scratchpad.md。
 
 ## 审查维度
 1. **完整性**：Why/What/Capabilities/Impact 是否齐全？有无缺失章节？
@@ -131,6 +142,19 @@ skill: openspec-apply-change
 - 代码全部完成后将所有未完成项标记为 \`- [x]\`，在 ACTION 报告中说明变更已全部实现
 - 不修改 \`proposal.md\`、\`design.md\` 或 \`.openspec.yaml\`
 - 直接用 read/write/edit/bash 等内置工具实现；不要尝试调用 task 二次委派。
+## scratchpad.md 共享缓存
+- 开工前 MUST 读 \`openspec/changes/<name>/scratchpad.md\`（若存在），复用已记录结论，禁止重复探索。
+- 交付前 MUST 将本轮新探索结论 append 到「实现探索」区（关键符号/数据流、新增涉及文件 \`path:line\`、验证/构建命令、已排除假设），标注 \`- [R<n> coder] <结论>\`。
+- 收到主 agent 中转的 code-reviewer P0/P1 关注点时，开工时先将关注点 append 进「代码审查范围」区，再开始修复。
+- 后续轮次只做增量：仅探索未记录的文件/符号/假设，不重复 read/grep 已记录内容；append-only，不得改写他人结论。
+
+## scratchpad.md 与代码不一致时的两档处置
+执行中发现代码现实与 scratchpad.md 记录不一致时，按两档客观判据处置；判据仅为「偏差是否影响任何 task 的前提或产出定义」，禁止主观估量「问题大小」：
+- **档一：事实快照过期**——偏差不影响任何 task 的前提或产出定义（纯探索性信息：路径 / 行号 / 符号 / 命令漂移）。处置：继续执行当前任务，不终止；在「实现探索」区 append supersede 修正。
+- **档二：契约动摇**——偏差导致 tasks / proposal / design / specs 的有效性存疑（前提不成立、产出定义变、代码现状与设计决策冲突）。处置：立即停止实现，输出 STATUS: blocked（无 SESSION）并说明冲突点，交由主 agent 裁决（改提案 / 确认「现状即新设计」/ 开新 change）。
+- supersede 标注格式：\`- [R<n> coder] supersede: <旧结论摘要>\`，随后一行以 \`- [R<n> coder]\` 标注新结论；两条均落「实现探索」分区，旧结论保留（append-only），不删除。
+- 交付摘要 SUMMARY 义务：本轮发生过 supersede 时，输出格式中的 SUMMARY 行 MUST 提及本次 supersede 清单。
+
 ## 验证（交付门槛）
 - 交付前必须跑过 **scoped 到本次改动面** 的 lint、typecheck 与针对性单测（proposal 约定的测试必须通过）；任一未通过不得交付，先修到通过再标记 ACTION: REVIEW_REQUIRED。
 - 项目级全量校验（全仓库 lint/typecheck/\`bun test\`）不属于自验证门槛：若失败可归因于并发 sibling 的半成品改动（与本改动无关），把失败连同「已排查与本改动无关」的证据作为上下文上报（交付摘要中注明），不要被其阻塞；最终由 code-reviewer 的全局验证兜底确认。
@@ -148,6 +172,7 @@ ACTION: REVIEW_REQUIRED
 CHANGE: <change-name 或 "general">
 STATUS: success | partial | blocked
 SESSION: <session_name>（仅 STATUS: blocked 且需 resume 时填写）
+SUMMARY: <交付摘要；若本轮有 supersede，必须包含「supersede: <清单>」>
 TASKS: N/M complete
 FILES: <逗号分隔的修改/创建文件列表>
 ---
@@ -173,6 +198,17 @@ tools: read, write, edit, bash, glob, grep, todo${model ? `\nmodel: ${model}` :
 ## 工作范围
 - **只负责提案文档**：proposal.md、design.md、tasks.md、specs/（openspec/changes/ 目录下）
 - 直接用内置工具；不要尝试调用 task 二次委派。
+## scratchpad.md 共享缓存
+变更目录下维护 \`openspec/changes/<name>/scratchpad.md\` 作四角色共享探索缓存（与 proposal.md/design.md/tasks.md 同级），固定四阶段分区：
+- \`## 调研与设计\`：调研结论、涉及文件（\`path:line\`）、已排除方案
+- \`## 提案审查关注点\`：proposal-reviewer 审查报告中的 P0/P1 与关注点（经主 agent 中转回流）
+- \`## 实现探索\`：coder 每轮 append 的关键符号/数据流、新增涉及文件、验证/构建命令、已排除假设
+- \`## 代码审查范围\`：code-reviewer 审查报告中的 P0/P1 与验证范围结论（经主 agent 中转回流）
+规则：
+- **出提案时 MUST 创建** \`openspec/changes/<name>/scratchpad.md\` 并写入四阶段骨架，预填「调研与设计」初始骨架：调研结论、涉及文件、已排除方案。
+- 后续轮次修改提案时，先读回 scratchpad.md：将 proposal-reviewer 关注点 append 进「提案审查关注点」区，新调研结论增量 append 进「调研与设计」区。
+- 条目以 \`- [R<n> planner] <结论>\` 标注轮次与角色；append-only，不得改写或删除他人结论。
+- 读回 scratchpad.md 时，以最新 supersede 条目为权威（识别 \`- [R<n> coder] supersede:\` 标记，其后的新结论优先于旧结论）。
 
 ## 提案拆分
 - 接大需求先评估契约边界:能拆则拆成多个小变更,先输出拆分建议(契约边界+提案清单)待主 agent 确认后再开写。

package/lib/provider-status.ts

@@ -0,0 +1,55 @@
+/**
+ * Process-local binary status for providers WITHOUT a usage report.
+ *
+ * A provider that has no usage fetcher has no authoritative quota source; the
+ * only observable exhaustion evidence is a 429/403 signal on the provider
+ * response or tool-execution paths. This module keeps that signal as a
+ * process-local `Map` (mirroring the `regionBlockedModels` in-process precedent
+ * in index.ts): absence of an entry means "可用", an explicit `markExhausted`
+ * flips it to "耗尽", and a subsequent strict-2xx provider response restores
+ * "可用". Nothing is persisted and nothing crosses processes — a 429 observed
+ * in one process is not broadcast to another, which is an accepted trade-off
+ * for a best-effort local hint.
+ *
+ * Keys are canonicalized (lowercase) so `ArkCodingPlan` and `arkcodingplan`
+ * share one entry.
+ */
+
+import { canonicalizeProvider } from './usage-resolver.js';
+
+interface ProviderStatus {
+    exhausted: boolean;
+    observedAt: number;
+}
+
+const state = new Map<string, ProviderStatus>();
+
+/** Mark a provider exhausted (429/403 observed). */
+export function markExhausted(provider: string): void {
+    const canonical = canonicalizeProvider(provider);
+    state.set(canonical, { exhausted: true, observedAt: Date.now() });
+}
+
+/** Clear the exhausted marker (strict 2xx response observed). */
+export function markAvailable(provider: string): void {
+    state.delete(canonicalizeProvider(provider));
+}
+
+/** True iff the provider has an explicit exhaustion marker (default: available). */
+export function isExhausted(provider: string): boolean {
+    return state.get(canonicalizeProvider(provider))?.exhausted ?? false;
+}
+
+/** Canonical ids of all currently-exhausted providers. */
+export function getExhaustedProviders(): ReadonlySet<string> {
+    const out = new Set<string>();
+    for (const [id, s] of state) {
+        if (s.exhausted) out.add(id);
+    }
+    return out;
+}
+
+/** Test seam: clear all process-local state. */
+export function _resetForTest(): void {
+    state.clear();
+}

package/lib/reachability-probe.ts

@@ -183,7 +183,7 @@ export interface HttpProbeOptions {
 }
 
 /** 区域封锁判定的关键词 */
-const REGION_BLOCK_TOKENS = ['region', 'not available', 'in your area'];
+export const REGION_BLOCK_TOKENS = ['region', 'not available', 'in your area'];
 
 /**
  * 对 TLS 可达的端点发送最小 HTTP 请求（1 token chat completion），

package/lib/status-probe.ts

@@ -0,0 +1,288 @@
+/**
+ * Provider 状态探测模块。
+ *
+ * 对无 usage fetcher 的 provider（如 ArkCodingPlan）主动发最小探测请求，
+ * 区分「429 类错误 vs 正常模型」，驱动底部 widget「可用/耗尽」二元态。
+ *
+ * 探测是 fire-and-forget 异步操作，绝不阻塞渲染路径。结果写入 provider-status.ts
+ * 的进程内状态机（exhausted 集合），渲染自动读取。
+ *
+ * 探测分类：
+ * - ok（2xx）→ markAvailable（清除耗尽）
+ * - exhausted（429，或 403 非 region）→ markExhausted
+ * - region-blocked（403 + region 关键词）→ markExhausted（归耗尽显示）
+ * - auth-error（401）/ model-not-found（404）/ network-error（异常/超时）→ 不写状态
+ *   （宁缺毋谎：无法区分「provider 真不可用」与「探测请求构造失真」）
+ *
+ * Cooldown ledger：进程内 Map<canonicalProvider, lastProbedAt>，复用 probe_ttl_ms。
+ * markStatusProbeStarted 在任何 await 之前写入，彻底关死 in-flight 竞态窗口。
+ */
+
+import { REGION_BLOCK_TOKENS } from './reachability-probe.js';
+import { canonicalizeProvider } from './usage-resolver.js';
+import { markExhausted, markAvailable } from './provider-status.js';
+
+// ── 类型 ────────────────────────────────────────────────────────────────
+
+/** 状态探测的分类结果。 */
+export type StatusProbeClass =
+  | 'ok'              // 2xx：真实模型、真实 key，请求走通
+  | 'exhausted'       // 429，或 403 非 region 文本
+  | 'region-blocked'  // 403 + region 关键词
+  | 'auth-error'      // 401
+  | 'model-not-found' // 404
+  | 'network-error';  // fetch 抛异常 / 超时
+
+/** 状态探测结果。 */
+export interface StatusProbeResult {
+  provider: string;
+  class: StatusProbeClass;
+  detail?: string;
+  probedAt: number;
+}
+
+/** 网络探测选项。 */
+export interface StatusProbeOptions {
+  baseUrl: string;
+  model: string;
+  apiKey: string;
+  timeoutMs: number;
+  fetchImpl?: typeof fetch;
+}
+
+/** 调度配置。 */
+export interface ScheduleConfig {
+  enabled: boolean;
+  ttlMs: number;
+  timeoutMs: number;
+  excluded: string[];
+}
+
+/** 调度选项。 */
+export interface ScheduleOptions {
+  placeholderIds: string[];
+  models: { id: string; provider: string; baseUrl?: string }[];
+  getApiKey?: (provider: string) => Promise<string | undefined>;
+  config: ScheduleConfig;
+  fetchImpl?: typeof fetch;
+}
+
+// ── 纯分类函数 ─────────────────────────────────────────────────────────
+
+/**
+ * 纯分类：HTTP 状态 + 响应体文本 → 分类。
+ * 无 IO，直接单测。
+ */
+export function classifyStatusResponse(status: number, bodyText: string): StatusProbeClass {
+  // 2xx → ok
+  if (status >= 200 && status < 300) {
+    return 'ok';
+  }
+  // 429 → exhausted
+  if (status === 429) {
+    return 'exhausted';
+  }
+  // 403 + region 关键词 → region-blocked，否则 exhausted
+  if (status === 403) {
+    const lower = bodyText.toLowerCase();
+    if (REGION_BLOCK_TOKENS.some((tok) => lower.includes(tok))) {
+      return 'region-blocked';
+    }
+    return 'exhausted';
+  }
+  // 401 → auth-error
+  if (status === 401) {
+    return 'auth-error';
+  }
+  // 404 → model-not-found
+  if (status === 404) {
+    return 'model-not-found';
+  }
+  // 其余一律 → network-error（detail 记原始 status）
+  return 'network-error';
+}
+
+// ── 网络探测函数 ───────────────────────────────────────────────────────
+
+/**
+ * 对单个 provider 执行状态探测。
+ * 绝不抛异常：所有错误/超时/解析失败 → network-error 结果。
+ */
+export async function probeProviderStatus(
+  provider: string,
+  opts: StatusProbeOptions,
+): Promise<StatusProbeResult> {
+  const fetchFn = opts.fetchImpl ?? fetch;
+  const url = `${opts.baseUrl.replace(/\/+$/, '')}/chat/completions`;
+
+  try {
+    const response = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${opts.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: opts.model,
+        messages: [{ role: 'user', content: 'hi' }],
+        max_tokens: 1,
+      }),
+      signal: AbortSignal.timeout(opts.timeoutMs),
+    });
+
+    let bodyText = '';
+    try {
+      bodyText = await response.text();
+    } catch {
+      // 响应体读取失败 → 按空文本处理
+      bodyText = '';
+    }
+
+    const classification = classifyStatusResponse(response.status, bodyText);
+    return {
+      provider,
+      class: classification,
+      detail: classification === 'network-error' ? `status ${response.status}` : undefined,
+      probedAt: Date.now(),
+    };
+  } catch (e: unknown) {
+    // 网络/超时/AbortError → network-error，绝不抛
+    const err = e as Error & { name?: string };
+    const detail = err.name === 'AbortError' || err.name === 'TimeoutError'
+      ? 'timeout'
+      : (err.message ?? String(e));
+    return {
+      provider,
+      class: 'network-error',
+      detail,
+      probedAt: Date.now(),
+    };
+  }
+}
+
+// ── Cooldown ledger ─────────────────────────────────────────────────────
+
+const probeLedger = new Map<string, number>();
+
+/** 检查是否已到下次探测时间。 */
+export function isStatusProbeDue(provider: string, ttlMs: number): boolean {
+  const canonical = canonicalizeProvider(provider);
+  const lastProbedAt = probeLedger.get(canonical);
+  if (lastProbedAt === undefined) {
+    return true;
+  }
+  return Date.now() - lastProbedAt >= ttlMs;
+}
+
+/** 标记探测已开始（在任何 await 之前调用，关死竞态窗口）。 */
+export function markStatusProbeStarted(provider: string): void {
+  const canonical = canonicalizeProvider(provider);
+  probeLedger.set(canonical, Date.now());
+}
+
+/** 测试 seam：清空 ledger。 */
+export function _resetForTest(): void {
+  probeLedger.clear();
+}
+
+// ── 调度入口 ─────────────────────────────────────────────────────────
+
+/**
+ * 调度状态探测。
+ *
+ * 探测是 fire-and-forget 异步操作，绝不阻塞调用路径。
+ * 返回写入计数（可能为任意非负整数），调用方可据此判断是否需要重渲染。
+ *
+ * 异常全部吞没：fetch 失败/超时/解析失败/状态机写入失败均不影响其他 provider。
+ */
+export async function scheduleStatusProbes(opts: ScheduleOptions): Promise<number> {
+  const { placeholderIds, models, getApiKey, config, fetchImpl } = opts;
+
+  // 快速短路：未启用或无可用的 getApiKey → 零请求，不抛 TypeError
+  if (!config.enabled || getApiKey === undefined) {
+    return 0;
+  }
+
+  // 同步过滤候选：excluded + 无 baseUrl/无模型
+  const excludedSet = new Set(config.excluded.map(canonicalizeProvider));
+  const modelMap = new Map<string, { id: string; baseUrl: string }>();
+  for (const m of models) {
+    if (m.baseUrl && !modelMap.has(canonicalizeProvider(m.provider))) {
+      modelMap.set(canonicalizeProvider(m.provider), { id: m.id, baseUrl: m.baseUrl });
+    }
+  }
+
+  const candidates = placeholderIds.filter((id) => {
+    const canonical = canonicalizeProvider(id);
+    if (excludedSet.has(canonical)) {
+      return false;
+    }
+    const modelInfo = modelMap.get(canonical);
+    if (!modelInfo) {
+      return false;
+    }
+    // cooldown 检查
+    if (!isStatusProbeDue(id, config.ttlMs)) {
+      return false;
+    }
+    return true;
+  });
+
+  if (candidates.length === 0) {
+    return 0;
+  }
+
+  // 对每个候选：先 markStatusProbeStarted（占位），再 await getApiKey
+  // 关死 in-flight 竞态窗口
+  const probePromises = candidates.map(async (provider) => {
+    markStatusProbeStarted(provider);
+    const apiKey = await getApiKey(provider);
+    if (!apiKey) {
+      // 无 key → 跳过请求但保留 cooldown 占位（下个 TTL 再查）
+      return null;
+    }
+    const modelInfo = modelMap.get(canonicalizeProvider(provider));
+    if (!modelInfo) {
+      return null;
+    }
+    return probeProviderStatus(provider, {
+      baseUrl: modelInfo.baseUrl,
+      model: modelInfo.id,
+      apiKey,
+      timeoutMs: config.timeoutMs,
+      fetchImpl,
+    });
+  });
+
+  // 并发探测，单个失败不连坐
+  const results = await Promise.allSettled(probePromises);
+  let written = 0;
+
+  for (const result of results) {
+    if (result.status === 'fulfilled') {
+      const probeResult = result.value;
+      if (!probeResult) {
+        continue; // 跳过的 provider
+      }
+      const canonical = canonicalizeProvider(probeResult.provider);
+      // 映射到状态机：exhausted/region-blocked → markExhausted；ok → markAvailable
+      if (probeResult.class === 'exhausted' || probeResult.class === 'region-blocked') {
+        markExhausted(probeResult.provider);
+        written++;
+        console.info(`[omp-opsx-addon] status probe: ${canonical} -> ${probeResult.class}`);
+      } else if (probeResult.class === 'ok') {
+        markAvailable(probeResult.provider);
+        written++;
+        console.info(`[omp-opsx-addon] status probe: ${canonical} -> ok`);
+      } else {
+        // auth-error/model-not-found/network-error 不写状态
+        console.warn(
+          `[omp-opsx-addon] status probe: ${canonical} -> ${probeResult.class}${probeResult.detail ? ` (${probeResult.detail})` : ''}`,
+        );
+      }
+    }
+    // rejected promise 在理论上不应发生（probeProviderStatus 已吞没所有异常），防御性忽略
+  }
+
+  return written;
+}

package/lib/system-prompt.ts

@@ -100,15 +100,15 @@ export function buildStaticPrompt(): string {
 | 审查代码实现 | task(agent:"reviewer", task:"审阅代码 + 执行全局验证（lint/单测/e2e）") |
 
 ## 2 个 Loop
-- **Loop 1 – Propose → Review**:planner 完成 → proposal-reviewer → P0/P1 发回 → 通过告知用户。Propose-review loop：最多 planner→reviewer 往复 2 轮。
-- **Loop 2 – Code → Review**:coder 完成(交付前自验证)→ code-reviewer 审阅 + 全局验证 → P0/P1 发回修复 → 仅 P2+ 视为通过。Code-review loop：最多 coder→reviewer 往复 3 轮(含首次实现),reviewer 兼执行全局验证。
+- **Loop 1 – Propose → Review**:planner 完成 → proposal-reviewer → P0/P1 发回 → 通过告知用户。Propose-review loop：最多 planner→reviewer 往复 2 轮。委派 planner/proposal-reviewer 的 task 描述须含『先读 openspec/changes/<name>/scratchpad.md，禁止重复探索』。
+- **Loop 2 – Code → Review**:coder 完成(交付前自验证)→ code-reviewer 审阅 + 全局验证 → P0/P1 发回修复 → 仅 P2+ 视为通过。Code-review loop：最多 coder→reviewer 往复 3 轮(含首次实现),reviewer 兼执行全局验证。委派 coder/code-reviewer 的 task 描述须含『先读 openspec/changes/<name>/scratchpad.md，禁止重复探索』。
 - 达上限时停止自动流转，向用户说明未解决的问题并请求决策。
 
 ## /goal 集成(可选)
 Planner 在 proposal 末尾输出 \`## Budget Estimate\`;主 agent 提取用于 \`/goal\`。
 
 ## 自动流程协作
-coder 输出 STATUS: blocked 且含 SESSION: → 阅读阻塞原因决策;收到 P0/P1 → 修复再审。
+coder 输出 STATUS: blocked 且含 SESSION: → 阅读阻塞原因决策;收到 P0/P1 → 修复再审。P0/P1 发回修复时 task 描述同样须含『先读 openspec/changes/<name>/scratchpad.md，禁止重复探索』。
 
 ## 上下文卫生（主 session 预算）
 - 代码调研/搜代码/理解架构 → task(agent:"scout")；主 session 不亲自 read 全文调研。
@@ -118,7 +118,7 @@ coder 输出 STATUS: blocked 且含 SESSION: → 阅读阻塞原因决策;收到
 - 主 session 上下文超过 ~50k tokens：必须先委托再继续，禁止继续亲自调研。`;
 }
 
-const STATIC_LINE_COUNT = buildStaticPrompt().split('\n').length;
+export const STATIC_LINE_COUNT = buildStaticPrompt().split('\n').length;
 
 /** Dynamic layer: Dispatch config + change status. Placed after the static
  *  layer so only this tail is re-prefilled when it changes between turns. */

package/lib/unified-config.ts

@@ -66,6 +66,7 @@ export interface OpsxYamlShape {
     probe_http_enabled?: boolean;
     probe_ttl_ms?: number;
     excluded_providers?: string[];
+    status_probe_enabled?: boolean;
     redis_enabled?: boolean;
     redis_host?: string;
     redis_port?: number;
@@ -102,6 +103,8 @@ export interface ResolvedOpsxConfig {
     probe_ttl_ms: number;
     /** 静态排除的 provider 列表（零探测成本） */
     excluded_providers: string[];
+    /** 是否开启状态探测，默认 true */
+    status_probe_enabled: boolean;
     /** 是否启用本地 Redis 实时中转（默认 true；false 时纯文件路径）。 */
     redis_enabled: boolean;
     /** Redis host（默认 127.0.0.1）。 */
@@ -309,6 +312,7 @@ export function parseOpsxConfig(
         probe_http_enabled: parseProbeBool(obj.probe_http_enabled, 'probe_http_enabled', false, localWarn),
         probe_ttl_ms: parsePositiveInt(obj.probe_ttl_ms, 'probe_ttl_ms', 600_000, localWarn),
         excluded_providers: parseStringArray(obj.excluded_providers, 'excluded_providers', localWarn),
+        status_probe_enabled: parseProbeBool(obj.status_probe_enabled, 'status_probe_enabled', true, localWarn),
         redis_enabled: parseProbeBool(obj.redis_enabled, 'redis_enabled', true, localWarn),
         redis_host: redisHost,
         redis_port: parsePositiveInt(obj.redis_port, 'redis_port', 6379, localWarn),
@@ -359,6 +363,7 @@ function pickTopLevelKeys(raw: OpsxYamlShape): OpsxYamlShape {
         probe_http_enabled: raw.probe_http_enabled,
         probe_ttl_ms: raw.probe_ttl_ms,
         excluded_providers: raw.excluded_providers,
+        status_probe_enabled: raw.status_probe_enabled,
         redis_enabled: raw.redis_enabled,
         redis_host: raw.redis_host,
         redis_port: raw.redis_port,
@@ -449,6 +454,7 @@ export function readOpsxSettingsFromPaths(
     merged.probe_http_enabled = projectTop.probe_http_enabled ?? globalTop.probe_http_enabled;
     merged.probe_ttl_ms = projectTop.probe_ttl_ms ?? globalTop.probe_ttl_ms;
     merged.excluded_providers = projectTop.excluded_providers ?? globalTop.excluded_providers;
+    merged.status_probe_enabled = projectTop.status_probe_enabled ?? globalTop.status_probe_enabled;
     merged.redis_enabled = projectTop.redis_enabled ?? globalTop.redis_enabled;
     merged.redis_host = projectTop.redis_host ?? globalTop.redis_host;
     merged.redis_port = projectTop.redis_port ?? globalTop.redis_port;

package/lib/usage-render.ts

@@ -289,18 +289,33 @@ export const buildColumn = (r: UsageReport, painter: Painter = ansiPainter, load
 };
 
 /**
- * Render a logged-in provider that has no report yet as a header + a single
- * placeholder row (`—`). Placeholder identity is always carried by an explicit id
- * (see `renderUsageReports` `placeholderIds`); it is NEVER inferred from an empty
- * `limits` array, so a real fetch that returns no windows is not mistaken for a
- * logged-in-but-unfetched provider.
+ * Render a real report whose `limits` array is empty — a fetch succeeded but
+ * returned no usable windows. This is NOT a logged-in-but-unfetched provider:
+ * it keeps the existing `—` marker (never the binary 可用/耗尽 body) so its
+ * rendering is byte-identical to the pre-binary-status behavior.
  */
-export const buildPlaceholderColumn = (provider: string, painter: Painter = ansiPainter, loading = false): string[] => {
+export const buildEmptyReportColumn = (provider: string, painter: Painter = ansiPainter, loading = false): string[] => {
     const { label, color } = providerLabel(provider);
-    // Loading placeholder: body shows ⟳ (fetch in flight) instead of the idle —.
     return [painter.header(loading ? `${label}⟳` : label, color), painter.balance(loading ? "⟳" : "—")];
 }
 
+/**
+ * Render a logged-in provider that has no report yet as a header + a single
+ * binary-status row (`可用` / `耗尽` / `⟳`). Placeholder identity is always
+ * carried by an explicit id (see `renderUsageReports` `placeholderIds`); it is
+ * NEVER inferred from an empty `limits` array, so a real fetch that returns no
+ * windows is not mistaken for a logged-in-but-unfetched provider. `exhausted`
+ * reflects the process-local 429/403 signal (see `lib/provider-status.ts`).
+ */
+export const buildPlaceholderColumn = (provider: string, painter: Painter = ansiPainter, loading = false, exhausted = false): string[] => {
+    const { label, color } = providerLabel(provider);
+    const body = loading ? "⟳" : exhausted ? "耗尽" : "可用";
+    return [
+        painter.header(loading ? `${label}⟳` : label, color),
+        exhausted ? painter.exhausted(body) : painter.balance(body),
+    ];
+}
+
 // ── flex-wrap table layout ───────────────────────────────────────────
 
 const SEP_VISUAL = 3;
@@ -314,6 +329,7 @@ export function renderUsageReports(
     loadingProviders?: ReadonlySet<string>,
     consumptionTracks?: Map<string, ConsumptionTrack>,
     usageEstimates?: Map<string, string>,
+    exhaustedProviders?: ReadonlySet<string>,
 ): string[] {
     // Placeholder providers are logged-in but unfetched this round. Their ids are
     // explicit (never inferred from `limits.length === 0`); dedupe against reports
@@ -329,7 +345,7 @@ export function renderUsageReports(
     interface ProviderColumn { provider: string; col: string[] }
     const cols: ProviderColumn[] = (reports ?? []).map((r) => {
         const col = r.limits.length === 0
-            ? buildPlaceholderColumn(r.provider, painter, loading.has(r.provider))
+            ? buildEmptyReportColumn(r.provider, painter, loading.has(r.provider))
             : buildColumn(r, painter, loading.has(r.provider));
         if (!col) return { provider: r.provider, col: [] };
         // Second-level estimate override replaces the usage line (balance style).
@@ -338,7 +354,7 @@ export function renderUsageReports(
         return { provider: r.provider, col };
     });
     for (const id of placeholders) {
-        cols.push({ provider: id, col: buildPlaceholderColumn(id, painter, loading.has(id)) });
+        cols.push({ provider: id, col: buildPlaceholderColumn(id, painter, loading.has(id), exhaustedProviders?.has(id)) });
     }
     const valid = cols.filter((c) => c.col.length > 0);
     if (valid.length === 0) return [];

package/lib/usage-resolver.ts

@@ -41,9 +41,16 @@ export interface DirectFetcher {
  */
 const PROVIDER_ALIAS: Record<string, string> = {};
 
-/** Normalize a provider id to its canonical form (no-op if already canonical). */
+/**
+ * Normalize a provider id to its canonical form: lowercase first, then alias
+ * mapping. models.yml config keys are mixed-case (`ArkCodingPlan`), DB
+ * credentials and message events are lowercase (`arkcodingplan`), and the
+ * harness compares ids case-insensitively — lowercase unifies all three so a
+ * provider never surfaces as two columns or two waveform tracks.
+ */
 export function canonicalizeProvider(id: string): string {
-    return PROVIDER_ALIAS[id] ?? id;
+    const k = id.toLowerCase();
+    return PROVIDER_ALIAS[k] ?? k;
 }
 
 /** Providers whose direct fetcher reports locally-detectable credentials (no network). */

package/lib/usage-widget.ts

@@ -55,6 +55,7 @@ export class UsageTable implements Component {
     readonly #loadingProviders?: ReadonlySet<string>;
     readonly #consumptionTracks?: Map<string, ConsumptionTrack>;
     readonly #usageEstimates?: Map<string, string>;
+    readonly #exhaustedProviders?: ReadonlySet<string>;
 
     constructor(
         reports: UsageReport[],
@@ -63,6 +64,7 @@ export class UsageTable implements Component {
         loadingProviders?: ReadonlySet<string>,
         consumptionTracks?: Map<string, ConsumptionTrack>,
         usageEstimates?: Map<string, string>,
+        exhaustedProviders?: ReadonlySet<string>,
     ) {
         this.#reports = reports;
         this.#painter = painter;
@@ -70,6 +72,7 @@ export class UsageTable implements Component {
         this.#loadingProviders = loadingProviders;
         this.#consumptionTracks = consumptionTracks;
         this.#usageEstimates = usageEstimates;
+        this.#exhaustedProviders = exhaustedProviders;
     }
 
     render(width: number): readonly string[] {
@@ -83,6 +86,7 @@ export class UsageTable implements Component {
             this.#loadingProviders,
             this.#consumptionTracks,
             this.#usageEstimates,
+            this.#exhaustedProviders,
         );
     }
 
@@ -107,6 +111,7 @@ export function createUsageWidget(
     loadingProviders?: ReadonlySet<string>,
     consumptionTracks?: Map<string, ConsumptionTrack>,
     usageEstimates?: Map<string, string>,
+    exhaustedProviders?: ReadonlySet<string>,
 ): ExtensionUiComponentFactory {
-    return (_tui, theme) => new UsageTable(reports, themePainter(theme), placeholderIds, loadingProviders, consumptionTracks, usageEstimates);
+    return (_tui, theme) => new UsageTable(reports, themePainter(theme), placeholderIds, loadingProviders, consumptionTracks, usageEstimates, exhaustedProviders);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genee/omp-opsx-addon",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Pi Extension: OpenSpec workflow orchestration - coder/reviewer/planner agents, session title & progress",
   "main": "./index.ts",
@@ -25,10 +25,14 @@
     "opsx"
   ],
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "omp": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "license": "MIT",
   "peerDependencies": {