@genee/omp-opsx-addon 0.10.0 → 0.12.0

package/README.md

@@ -458,8 +458,10 @@ quality_preference: balanced   # balanced（缺省，逐字节现状）| cost |
 - top 补选没有可用模型（候选耗尽/allowlist 全过滤）时，slow 不写覆盖、warn 汇总
   （`no-pick`），命令不中断；无任何模型时计划为空，与既有「模型注册表不可用」分支一致。
 - 覆盖为 **session 作用域、不写盘**：`overrideModelRoles` 只写 runtime overlay，
-  session 结束即还原；不会修改你的 `~/.omp/agent/config.yml`。每次应用前先
-  `clearOverride('modelRoles')`，避免上一 selector 的旧 role 值残留；`reset` 重算无约束
+  session 结束即还原；不会修改你的 `~/.omp/agent/config.yml`。每次应用前先清除本 session
+  的 modelRoles 运行时覆盖（宿主 18.3+ 走注册表句柄 `clearOverrideValue(cfgModelRoles)`，
+  ≤18.1 走路径式 `clearOverride('modelRoles')`，两者由 `lib/host-settings-adapter.ts`
+  统一选取），避免上一 selector 的旧 role 值残留；`reset` 重算无约束
   默认并覆盖（**不清空**，否则回落 config 硬钉）。
 
 > **手动清理建议**：若全局 `~/.omp/agent/config.yml` 里有 `modelRoles.smol` 钉在会耗尽的

package/index.ts

@@ -843,7 +843,7 @@ export interface ConcurrencyAssemblyDeps {
     configPath: string;
     /** Agent dir the log reader / `model_perf` path derive from. */
     agentDir?: string;
-    /** Host settings port for the hot-apply (`settings.override`). */
+    /** Host settings singleton for the hot-apply (API generation resolved inside the adapter). */
     settings?: SettingsPort | null;
     /** Cross-process ① aggregation channel (`null` → local-only + warn). */
     redis?: ConcurrencyRedisPort | null;
@@ -910,11 +910,15 @@ export default (pi: ExtensionAPI) => {
     // but the model repeatedly breaks sloppy control lines too — retry loops
     // burn tokens and abort agents. Point it at the simplest old_string/
     // new_string "replace" variant instead.
-    // Preferred path: `settings.override` (in-memory, per-session). omp
-    // 18.0.11 removed `edit.modelVariants` from the settings schema, so on
-    // that host the pin is persisted into the global config.yml once — the
-    // host reads the merged view directly, making the file equivalent.
-    applyEditVariantPin(pi, { 'deepseek-v4-flash': 'replace' });
+    // Preferred path: the runtime override (registry handle on omp >= 18.3,
+    // `settings.override` before that), in-memory and per-session. omp 18.0.11
+    // dropped `edit.modelVariants` from the path-based settings schema, so on
+    // hosts where neither runtime API reaches it the pin is persisted into the
+    // global config.yml once — the host reads the merged view directly, making
+    // the file equivalent. Fire-and-forget: the pin applies from the first
+    // edit turn, nothing here depends on its completion, and the function
+    // never rejects (it warns through the host logger).
+    void applyEditVariantPin(pi, { 'deepseek-v4-flash': 'replace' });
     const directory = process.cwd();
     const warn = (msg: string) => pi.logger.warn(msg);
     const opsxConfig = readOpsxSettings(directory, warn, opsxGlobalHomeForTests ?? homedir());
@@ -1155,8 +1159,8 @@ export default (pi: ExtensionAPI) => {
     // copy in node_modules is a separate, uninitialized instance — writing to
     // it was a no-op). This thin wrapper is the single call site the
     // constrained-period tick-reselect path (auto-model-family) also uses.
-    const applyRoleModel = (sel: SelectionContext): void => {
-        applyRoleModelOverrides(pi.pi?.settings, sel, warn);
+    const applyRoleModel = async (sel: SelectionContext): Promise<void> => {
+        await applyRoleModelOverrides(pi.pi?.settings, sel, warn);
     };
 
     // Instance-level usage-record claim: true only while this instance's
@@ -1170,10 +1174,15 @@ export default (pi: ExtensionAPI) => {
     let recordsOwnUsage = false;
 
     // ── adaptive provider concurrency: host seams ─────────────────
-    /** Host settings port for the control loop's hot-apply (narrowed to `override`). */
+    /**
+     * Host settings port for the control loop's hot-apply. The API shape is the
+     * adapter's business (`lib/host-settings-adapter.ts`: registry handles on
+     * omp >= 18.3, path-based `override` before that), so any object — i.e.
+     * every host generation — qualifies here.
+     */
     const hostSettingsPort = (): SettingsPort | null => {
-        const settings = pi.pi?.settings as unknown as { override?: unknown } | undefined;
-        return settings && typeof settings.override === 'function' ? (settings as SettingsPort) : null;
+        const settings = pi.pi?.settings as unknown;
+        return settings && typeof settings === 'object' ? (settings as SettingsPort) : null;
     };
     /** Config root + agent dir for the control loop (host settings, else `~/.omp/agent`). */
     const resolveConcurrencyPaths = (): { agentDir: string; configPath: string } => {
@@ -1749,7 +1758,7 @@ export default (pi: ExtensionAPI) => {
                     false,
                     reprobeUnreachable ? { reprobeUnreachable: true } : undefined,
                 );
-                applyRoleModel(sel);
+                await applyRoleModel(sel);
                 const picked = sel.selectorResults.reviewer?.picked;
                 if (picked && ctx.model && `${ctx.model.provider}/${ctx.model.id}` !== `${picked.provider}/${picked.id}`) {
                     await pi.setModel(picked);
@@ -1995,7 +2004,7 @@ export default (pi: ExtensionAPI) => {
                         }
                     }
                     selection = freshSel;
-                    applyRoleModel(freshSel);
+                    await applyRoleModel(freshSel);
                     const content = changes.length > 0
                         ? renderPickModelReport('refresh', { action: '已刷新', constraint: formatFamilyConstraint(familyConstraint) || undefined, detail: [changes.join('\n')] }, symbols)
                         : renderPickModelReport('refresh', { action: '已刷新 · 所有模型状态正常，无需切换' }, symbols);
@@ -2062,7 +2071,7 @@ export default (pi: ExtensionAPI) => {
                     if (newPrimary) await pi.setModel(newPrimary);
                     selection = sel;
                     selectionHealthKey = buildSelectionHealthKey(health, reach, familyConstraint, collapsed);
-                    applyRoleModel(sel);
+                    await applyRoleModel(sel);
                     pi.sendMessage({
                         customType: 'pick-model',
                         content: renderPickModelReport('reset', {
@@ -2235,7 +2244,7 @@ export default (pi: ExtensionAPI) => {
                     if (newPrimary) await pi.setModel(newPrimary);
                     selection = sel;
                     selectionHealthKey = buildSelectionHealthKey(health, reach, familyConstraint, collapsed);
-                    applyRoleModel(sel);
+                    await applyRoleModel(sel);
                     const content = renderPickModelReport('switch', {
                         action: '已切换 selector 约束',
                         constraint: formatFamilyConstraint(familyConstraint) || undefined,

package/lib/concurrency-control.ts

@@ -471,7 +471,7 @@ export interface ConcurrencyControlOptions {
     dbPath?: string;
     /** Cross-process ① aggregation channel; `null`/omitted disables it (warn + local only). */
     redis?: ConcurrencyRedisPort | null;
-    /** Settings hot-apply seam; omitted → file write only. */
+    /** Host settings singleton for the hot-apply seam; omitted → file write only. */
     settings?: SettingsPort | null;
     /** Per-provider ceiling overrides (`concurrency_ceiling_by_provider`). */
     ceilingByProvider?: Record<string, number>;
@@ -868,7 +868,7 @@ export class ConcurrencyController {
             const shared = sharedMap[provider];
             const divergedFromShared = typeof shared === 'number' && shared !== next.limit;
             if ((evaluation.increased || evaluation.decreased || decay.moved || divergedFromShared) && isWriter) {
-                view.written = this.persistLimit(provider, next.limit, sharedMap, now);
+                view.written = await this.persistLimit(provider, next.limit, sharedMap, now);
             }
             result.providers[provider] = view;
         }
@@ -1145,12 +1145,12 @@ export class ConcurrencyController {
         return Math.max(1, Math.ceil((interval * AGGREGATION_TTL_INTERVALS) / 1000));
     }
 
-    private persistLimit(
+    private async persistLimit(
         provider: string,
         limit: number,
         sharedMap: Record<string, number>,
         now: number,
-    ): boolean {
+    ): Promise<boolean> {
         // Write gate (task 4.2): |Δ| >= 1 AND more than
         // concurrency_write_min_interval_ms since this provider's last write.
         const gate = shouldWriteLimit({
@@ -1179,7 +1179,7 @@ export class ConcurrencyController {
             return false;
         }
         // Adopt the in-lock read: it is the freshest view of every provider, so
-        // the rest of this tick and the whole-key `settings.override` below never
+        // the rest of this tick and the whole-key hot-apply override below never
         // carry a snapshot taken before another process's write landed.
         if (outcome.limits) {
             for (const [id, value] of Object.entries(outcome.limits)) sharedMap[id] = value;
@@ -1188,7 +1188,7 @@ export class ConcurrencyController {
         this.lastWriteAt.set(provider, now);
         if (this.settings) {
             try {
-                const applied = applyLimit({
+                const applied = await applyLimit({
                     settings: this.settings,
                     merged: outcome.limits ?? merged,
                     provider,

package/lib/concurrency-writer.ts

@@ -38,6 +38,7 @@ import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statS
 import { dirname } from 'path';
 import { YAML } from 'bun';
 import { clampLimit } from './concurrency-tuner.js';
+import { overrideProviderMaxInFlight } from './host-settings-adapter.js';
 import { canonicalizeProvider } from './usage-resolver.js';
 
 /** Sink for degradation notices; defaults to a no-op. */
@@ -218,8 +219,8 @@ export function readManagedLimits(
 /**
  * Merge one provider's new limit into the **complete** per-provider map.
  * `providers.maxInFlightRequests` is a whole-key override on the host side, so
- * every caller MUST pass the full map (this is the map that goes to
- * `settings.override` and to {@link writeManagedLimit}).
+ * every caller MUST pass the full map (this is the map that goes to the
+ * hot-apply override — {@link applyLimit} — and to {@link writeManagedLimit}).
  */
 export function buildMergedMap(
     current: Record<string, number>,
@@ -582,10 +583,15 @@ export function writeManagedLimit(args: WriteManagedLimitArgs): WriteManagedLimi
 }
 
 /**
- * Injected host settings port (`pi.pi.settings`), narrowed to the call we make.
+ * Injected host settings port (`pi.pi.settings`).
+ *
+ * Only the identity of the host singleton matters here: the hot-apply goes
+ * through `lib/host-settings-adapter.ts`, which resolves the API generation
+ * (registry handle on omp >= 18.3, path-based `override` before that). Hence
+ * `override` is optional — a host that dropped it is still a usable port.
  */
 export interface SettingsPort {
-    override(path: string, value: unknown): void;
+    override?(path: string, value: unknown): void;
 }
 
 export interface ApplyLimitArgs {
@@ -604,8 +610,10 @@ export interface ApplyLimitResult {
 }
 
 /**
- * Hot-apply the shared map in this process via
- * `settings.override('providers.maxInFlightRequests', merged)`.
+ * Hot-apply the shared map in this process through the host settings runtime
+ * override (`providers.maxInFlightRequests`: registry handle on omp >= 18.3,
+ * path-based `settings.override` before that — both via
+ * `lib/host-settings-adapter.ts`).
  *
  * `providers.maxInFlightRequests` is a **whole-key override**, so the second
  * argument MUST be the complete per-provider map — passing only the target
@@ -614,13 +622,14 @@ export interface ApplyLimitResult {
  * (the caller keeps the previous value), while a partial map would silently
  * make the omitted providers unlimited. When the API throws (host schema moved
  * on), the persisted config is untouched — the host config watcher picks the
- * value up — and the failure is warned, never fatal.
+ * value up — and the failure is warned, never fatal. Async because the adapter
+ * loads host handles by dynamic import.
  */
-export function applyLimit(args: ApplyLimitArgs): ApplyLimitResult {
+export async function applyLimit(args: ApplyLimitArgs): Promise<ApplyLimitResult> {
     const warn = args.warn ?? NO_WARN;
     const settings = args.settings;
-    if (!settings || typeof settings.override !== 'function') {
-        warn('[omp-opsx-addon] concurrency: settings.override unavailable; skipping hot apply (config file value still applies)');
+    if (!settings) {
+        warn('[omp-opsx-addon] concurrency: settings unavailable; skipping hot apply (config file value still applies)');
         return { applied: false, reason: 'settings-unavailable' };
     }
     const provider = canonicalizeProvider(args.provider.trim());
@@ -631,15 +640,18 @@ export function applyLimit(args: ApplyLimitArgs): ApplyLimitResult {
     const payload = buildMergedMap(args.merged ?? {}, provider, args.value);
     for (const [id, value] of Object.entries(payload)) {
         if (!id || typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
-            warn(`[omp-opsx-addon] concurrency: refusing settings.override — invalid map entry ${JSON.stringify(id)}: ${JSON.stringify(value)}`);
+            warn(`[omp-opsx-addon] concurrency: refusing the hot-apply override — invalid map entry ${JSON.stringify(id)}: ${JSON.stringify(value)}`);
             return { applied: false, reason: 'invalid-merged' };
         }
     }
     try {
-        settings.override('providers.maxInFlightRequests', payload);
+        if (!(await overrideProviderMaxInFlight(settings, payload))) {
+            warn('[omp-opsx-addon] concurrency: no settings runtime-override API available (host handle / settings.override); skipping hot apply (config file value still applies)');
+            return { applied: false, reason: 'settings-unavailable' };
+        }
         return { applied: true };
     } catch (err) {
-        warn(`[omp-opsx-addon] concurrency: settings.override failed (${message(err)}); the host config watcher will apply the persisted value`);
+        warn(`[omp-opsx-addon] concurrency: settings hot-apply failed (${message(err)}); the host config watcher will apply the persisted value`);
         return { applied: false, reason: 'override-failed' };
     }
 }

package/lib/cursor-auth.ts

@@ -84,30 +84,46 @@ export function isJwtExpired(token: string, nowMs: number = Date.now()): boolean
     return exp * 1000 <= nowMs;
 }
 
+function queryTokensFromDb(db: Database): CursorTokenStore | null {
+    const row = (key: string): string | undefined => {
+        const r = db.query('SELECT value FROM ItemTable WHERE key = ?').get(key) as
+            | { value?: unknown }
+            | null
+            | undefined;
+        if (!r || r.value == null) return undefined;
+        const v = r.value;
+        return typeof v === 'string' ? v : Buffer.isBuffer(v) ? v.toString('utf8') : String(v);
+    };
+    const accessToken = row('cursorAuth/accessToken')?.trim() || undefined;
+    const refreshToken = row('cursorAuth/refreshToken')?.trim() || undefined;
+    const membershipType = row('cursorAuth/stripeMembershipType')?.trim() || undefined;
+    if (!accessToken && !refreshToken) return null;
+    return { accessToken, refreshToken, membershipType };
+}
+
 function defaultReadTokensFromDb(dbPath: string): CursorTokenStore | null {
-    try {
-        const db = new Database(dbPath, { readonly: true });
+    // Read-only first. Bun's bundled SQLite defers the open to the first
+    // prepare, where a live Cursor DB (active WAL/locks on APFS) can raise
+    // SQLITE_CANTOPEN even though the file is readable — plain python3 and a
+    // default read-write handle both work. So a failed readonly pass falls
+    // back to the default open; the SHARED lock is only held for the three
+    // key reads before we close, same footprint as any external reader.
+    for (const opts of [{ readonly: true } as const, undefined]) {
+        let db: Database;
         try {
-            const row = (key: string): string | undefined => {
-                const r = db.query('SELECT value FROM ItemTable WHERE key = ?').get(key) as
-                    | { value?: unknown }
-                    | null
-                    | undefined;
-                if (!r || r.value == null) return undefined;
-                const v = r.value;
-                return typeof v === 'string' ? v : Buffer.isBuffer(v) ? v.toString('utf8') : String(v);
-            };
-            const accessToken = row('cursorAuth/accessToken')?.trim() || undefined;
-            const refreshToken = row('cursorAuth/refreshToken')?.trim() || undefined;
-            const membershipType = row('cursorAuth/stripeMembershipType')?.trim() || undefined;
-            if (!accessToken && !refreshToken) return null;
-            return { accessToken, refreshToken, membershipType };
+            db = new Database(dbPath, opts);
+        } catch {
+            continue;
+        }
+        try {
+            return queryTokensFromDb(db);
+        } catch {
+            // Try the next open mode.
         } finally {
             db.close();
         }
-    } catch {
-        return null;
     }
+    return null;
 }
 
 function readStore(env: NodeJS.ProcessEnv = process.env): CursorTokenStore {

package/lib/cursor-limit-status.ts

@@ -0,0 +1,250 @@
+/**
+ * Cursor usage-limit / slow-pool status via Connect RPC
+ * (`GetUsageLimitStatusAndActiveGrants`), plus note encode/decode for
+ * attaching the parsed status to a `UsageReport` without extending pi-ai types.
+ *
+ * Fail-soft everywhere: field drift / network errors / missing token → null /
+ * undefined, never throw. Module-level TTL cache absorbs intermittent RPC
+ * failures so the widget does not flap exhausted↔warning.
+ */
+
+import type { UsageReport } from '@oh-my-pi/pi-ai';
+import { resolveCursorAccessToken } from './cursor-auth.js';
+
+export const CURSOR_LIMIT_STATUS_URL =
+    'https://api2.cursor.sh/aiserver.v1.DashboardService/GetUsageLimitStatusAndActiveGrants';
+
+export const LIMIT_STATUS_TTL_MS = 5 * 60_000;
+export const LIMIT_STATUS_TIMEOUT_MS = 5000;
+
+export const CURSOR_LIMIT_STATUS_NOTE_PREFIX = 'cursorLimitStatus=';
+
+export interface CursorLimitStatus {
+    isInSlowPool: boolean;
+    stage?: string;
+    slownessMs?: number;
+    grantsRemainingCents: number;
+    grantsExpiresAtMs?: number;
+}
+
+export interface FetchCursorLimitStatusOpts {
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    resolveCursorToken?: () => Promise<{ accessToken: string } | null>;
+    nowMs?: () => number;
+}
+
+type CacheEntry = { status: CursorLimitStatus; atMs: number };
+
+let cache: CacheEntry | null = null;
+
+/** Module-level seam defaults (opts override these). Cleared by `_resetLimitStatusCacheForTest`. */
+let seamFetchImpl: typeof fetch | undefined;
+let seamResolveCursorToken: (() => Promise<{ accessToken: string } | null>) | undefined;
+let seamNowMs: (() => number) | undefined;
+
+export function _setLimitStatusSeamsForTest(seams: {
+    fetchImpl?: typeof fetch;
+    resolveCursorToken?: () => Promise<{ accessToken: string } | null>;
+    nowMs?: () => number;
+} | null): void {
+    if (!seams) {
+        seamFetchImpl = undefined;
+        seamResolveCursorToken = undefined;
+        seamNowMs = undefined;
+        return;
+    }
+    if ('fetchImpl' in seams) seamFetchImpl = seams.fetchImpl;
+    if ('resolveCursorToken' in seams) seamResolveCursorToken = seams.resolveCursorToken;
+    if ('nowMs' in seams) seamNowMs = seams.nowMs;
+}
+
+export function _resetLimitStatusCacheForTest(): void {
+    cache = null;
+    seamFetchImpl = undefined;
+    seamResolveCursorToken = undefined;
+    seamNowMs = undefined;
+}
+
+/**
+ * Defensive parse of the Connect JSON body. Returns null on any structural
+ * drift (missing policy status, non-boolean isInSlowPool, non-object body).
+ * Invalid grant entries are skipped; cents are summed from valid ones.
+ */
+export function parseCursorLimitStatusResponse(data: unknown): CursorLimitStatus | null {
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) return null;
+    const root = data as Record<string, unknown>;
+    const policy = root.usageLimitPolicyStatus;
+    if (policy === null || typeof policy !== 'object' || Array.isArray(policy)) return null;
+    const pol = policy as Record<string, unknown>;
+    if (typeof pol.isInSlowPool !== 'boolean') return null;
+
+    const stage = typeof pol.stage === 'string' ? pol.stage : undefined;
+    const slownessMs =
+        typeof pol.slownessMs === 'number' && Number.isFinite(pol.slownessMs) ? pol.slownessMs : undefined;
+
+    let grantsRemainingCents = 0;
+    let grantsExpiresAtMs: number | undefined;
+    const grants = root.activeGrants;
+    if (Array.isArray(grants)) {
+        for (const entry of grants) {
+            if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) continue;
+            const g = entry as Record<string, unknown>;
+            const raw = g.remainingCents;
+            if (typeof raw !== 'string') continue;
+            // Integer cents string only — reject floats / signs / whitespace-padded junk.
+            if (!/^\d+$/.test(raw)) continue;
+            const cents = Number(raw);
+            if (!Number.isSafeInteger(cents) || cents < 0) continue;
+            grantsRemainingCents += cents;
+            if (cents > 0) {
+                const expRaw = g.expiresAtMs;
+                const exp =
+                    typeof expRaw === 'string' && /^\d+$/.test(expRaw)
+                        ? Number(expRaw)
+                        : typeof expRaw === 'number'
+                          ? expRaw
+                          : NaN;
+                if (Number.isFinite(exp) && Number.isSafeInteger(exp)) {
+                    grantsExpiresAtMs =
+                        grantsExpiresAtMs === undefined ? exp : Math.max(grantsExpiresAtMs, exp);
+                }
+            }
+        }
+    } else if (grants !== undefined) {
+        // Present but not an array → drift; treat whole parse as unknown.
+        return null;
+    }
+
+    const out: CursorLimitStatus = {
+        isInSlowPool: pol.isInSlowPool,
+        grantsRemainingCents,
+    };
+    if (stage !== undefined) out.stage = stage;
+    if (slownessMs !== undefined) out.slownessMs = slownessMs;
+    if (grantsExpiresAtMs !== undefined) out.grantsExpiresAtMs = grantsExpiresAtMs;
+    return out;
+}
+
+/** Encode status into the structured note (omit absent optional fields). */
+export function encodeCursorLimitStatusNote(status: CursorLimitStatus): string {
+    const parts: string[] = [`isInSlowPool:${status.isInSlowPool ? 1 : 0}`];
+    if (status.stage !== undefined) parts.push(`stage:${status.stage}`);
+    if (status.slownessMs !== undefined) parts.push(`slownessMs:${status.slownessMs}`);
+    parts.push(`grantsCents:${status.grantsRemainingCents}`);
+    if (status.grantsExpiresAtMs !== undefined) parts.push(`grantsExpiryMs:${status.grantsExpiresAtMs}`);
+    return CURSOR_LIMIT_STATUS_NOTE_PREFIX + parts.join(';');
+}
+
+/**
+ * Tolerant note parse: unknown fields ignored, truncated/malformed note →
+ * undefined (never throws). Requires at least a recognizable isInSlowPool bit.
+ */
+export function parseCursorLimitStatusNote(notes?: string[]): CursorLimitStatus | undefined {
+    if (!notes) return undefined;
+    for (const n of notes) {
+        if (!n.startsWith(CURSOR_LIMIT_STATUS_NOTE_PREFIX)) continue;
+        const body = n.slice(CURSOR_LIMIT_STATUS_NOTE_PREFIX.length);
+        if (!body) return undefined;
+        const fields = new Map<string, string>();
+        for (const part of body.split(';')) {
+            if (!part) continue;
+            const colon = part.indexOf(':');
+            if (colon <= 0) continue;
+            fields.set(part.slice(0, colon), part.slice(colon + 1));
+        }
+        const slowRaw = fields.get('isInSlowPool');
+        if (slowRaw !== '0' && slowRaw !== '1') return undefined;
+        const grantsRaw = fields.get('grantsCents');
+        let grantsRemainingCents = 0;
+        if (grantsRaw !== undefined) {
+            if (!/^\d+$/.test(grantsRaw)) return undefined;
+            const g = Number(grantsRaw);
+            if (!Number.isSafeInteger(g) || g < 0) return undefined;
+            grantsRemainingCents = g;
+        }
+        const out: CursorLimitStatus = {
+            isInSlowPool: slowRaw === '1',
+            grantsRemainingCents,
+        };
+        const stage = fields.get('stage');
+        if (stage !== undefined && stage.length > 0) out.stage = stage;
+        const slowMs = fields.get('slownessMs');
+        if (slowMs !== undefined && /^-?\d+(\.\d+)?$/.test(slowMs)) {
+            const v = Number(slowMs);
+            if (Number.isFinite(v)) out.slownessMs = v;
+        }
+        const exp = fields.get('grantsExpiryMs');
+        if (exp !== undefined && /^\d+$/.test(exp)) {
+            const v = Number(exp);
+            if (Number.isSafeInteger(v)) out.grantsExpiresAtMs = v;
+        }
+        return out;
+    }
+    return undefined;
+}
+
+/**
+ * Return a new report whose notes carry the encoded status. Replaces any
+ * existing `cursorLimitStatus=` note; preserves all other notes. Idempotent.
+ */
+export function enhanceCursorReport(report: UsageReport, status: CursorLimitStatus): UsageReport {
+    const note = encodeCursorLimitStatusNote(status);
+    const prev = report.notes ?? [];
+    const kept = prev.filter((n) => !n.startsWith(CURSOR_LIMIT_STATUS_NOTE_PREFIX));
+    return { ...report, notes: [...kept, note] };
+}
+
+/**
+ * Fetch + parse Cursor limit status. Fail-soft: network / non-OK / no token /
+ * parse failure → null (or cached value within TTL). Success overwrites cache.
+ */
+export async function fetchCursorLimitStatus(
+    opts?: FetchCursorLimitStatusOpts,
+): Promise<CursorLimitStatus | null> {
+    const now = (opts?.nowMs ?? seamNowMs ?? Date.now)();
+    const fetchFn = opts?.fetchImpl ?? seamFetchImpl ?? fetch;
+    const resolveToken =
+        opts?.resolveCursorToken ??
+        seamResolveCursorToken ??
+        (async () => {
+            const resolved = await resolveCursorAccessToken();
+            return resolved?.accessToken ? { accessToken: resolved.accessToken } : null;
+        });
+
+    try {
+        const auth = await resolveToken();
+        if (!auth?.accessToken) {
+            return softFail(now);
+        }
+        const res = await fetchFn(CURSOR_LIMIT_STATUS_URL, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${auth.accessToken}`,
+                'Connect-Protocol-Version': '1',
+                'x-cursor-client-version': '0.1.0',
+            },
+            body: JSON.stringify({}),
+            signal: AbortSignal.timeout(opts?.timeoutMs ?? LIMIT_STATUS_TIMEOUT_MS),
+        });
+        if (!res.ok) return softFail(now);
+        let data: unknown;
+        try {
+            data = await res.json();
+        } catch {
+            return softFail(now);
+        }
+        const parsed = parseCursorLimitStatusResponse(data);
+        if (!parsed) return softFail(now);
+        cache = { status: parsed, atMs: now };
+        return parsed;
+    } catch {
+        return softFail(now);
+    }
+}
+
+function softFail(now: number): CursorLimitStatus | null {
+    if (cache && now - cache.atMs < LIMIT_STATUS_TTL_MS) return cache.status;
+    return null;
+}

package/lib/edit-variant-pin.ts

@@ -2,9 +2,11 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import type { ExtensionAPI } from '@oh-my-pi/pi-coding-agent';
+import { overrideEditModelVariants } from './host-settings-adapter.js';
 
 /**
- * Runtime edit-variant pin fallback for omp >= 18.0.11.
+ * Runtime edit-variant pin, with a persisted fallback for hosts that no longer
+ * expose `edit.modelVariants` to the runtime settings API.
  *
  * The host hard-maps deepseek-v4-flash to the sloppy §/» marker grammar (it
  * misreads hashline ranges), but the model repeatedly breaks sloppy control
@@ -12,11 +14,14 @@ import type { ExtensionAPI } from '@oh-my-pi/pi-coding-agent';
  * plain old_string/new_string "replace" variant instead.
  *
  * Up to 17.x this extension did that via
- * `settings.override("edit.modelVariants", …)`. omp 18.0.11 dropped
- * `edit.modelVariants` from the settings schema, so `override()` throws
- * inside `get()`: the path-segment table has no entry for it and `getByPath`
- * iterates `undefined`. The host still honors the key when it arrives through
- * the global config file — `#getEditVariantEntries` reads the merged view
+ * `settings.override("edit.modelVariants", …)`; omp 18.3 replaced that
+ * path-based API with registry handles (`edit.modelVariants` handle →
+ * `handle.override(settings, …)`, see `lib/host-settings-adapter.ts`), so the
+ * runtime path lives on. On 18.0.11–18.x hosts whose path-based schema
+ * dropped `edit.modelVariants`, `override()` throws inside `get()`: the
+ * path-segment table has no entry for it and `getByPath` iterates
+ * `undefined`. Those hosts still honor the key when it arrives through the
+ * global config file — `#getEditVariantEntries` reads the merged view
  * directly and `resolveEditMode` prefers the per-model variant over
  * `edit.mode` — so persisting once is functionally equivalent to the runtime
  * pin.
@@ -102,38 +107,41 @@ export function persistEditVariantPin(
 }
 
 /**
- * Pin the edit variant for the target models.
+ * Pin the edit variant for the target models. Never rejects: every failure is
+ * warned through the host logger (the caller fires this and forgets it).
  *
- * Preferred path: in-memory `settings.override` (omp < 18.0.11). When that
- * throws (18.0.11 removed the schema path), persist into the global
- * config.yml once — idempotent, effective from the next session.
+ * Preferred path: the in-memory runtime override — the `edit.modelVariants`
+ * registry handle on omp >= 18.3, the path-based `settings.override` before
+ * that (both resolved inside `lib/host-settings-adapter.ts`). When this host
+ * offers no runtime path that reaches the setting (18.0.11+ dropped it from
+ * the path-based schema), persist into the global config.yml once —
+ * idempotent, effective from the next session.
  */
-export function applyEditVariantPin(pi: ExtensionAPI, pin: Record<string, string>): void {
+export async function applyEditVariantPin(pi: ExtensionAPI, pin: Record<string, string>): Promise<void> {
     // `pi.pi` is the whole SDK module namespace; its `settings` field has no
-    // declared runtime instance type on the extension-facing surface, so
-    // narrow to the two methods we call (the same shape the host's Settings
-    // class exposes publicly).
-    const settings = pi.pi?.settings as unknown as
-        | { override(path: string, value: unknown): void; getAgentDir?: () => string }
-        | undefined;
-    if (!settings) {
+    // declared runtime instance type on the extension-facing surface, so the
+    // `in`/`typeof` checks below are the whole contract.
+    const settings: unknown = pi.pi?.settings;
+    if (!settings || typeof settings !== 'object') {
         pi.logger?.warn('[omp-opsx-addon] pi.pi.settings unavailable; edit variant pin skipped');
         return;
     }
 
     try {
-        settings.override('edit.modelVariants', pin);
-        return;
+        if (await overrideEditModelVariants(settings, pin)) return;
     } catch {
-        /* settings schema no longer knows this path — persist instead */
+        /* host schema no longer knows the path — persist instead */
     }
 
     try {
-        let agentDir: string;
-        try {
-            agentDir = settings.getAgentDir?.() ?? '';
-        } catch {
-            agentDir = '';
+        let agentDir = '';
+        if ('getAgentDir' in settings && typeof settings.getAgentDir === 'function') {
+            try {
+                const dir = settings.getAgentDir();
+                if (typeof dir === 'string') agentDir = dir;
+            } catch {
+                agentDir = '';
+            }
         }
         if (!agentDir) agentDir = path.join(os.homedir(), '.omp', 'agent');
 

package/lib/host-settings-adapter.ts

@@ -0,0 +1,227 @@
+/**
+ * Host Settings API compatibility adapter (change: omp-18.3-settings-api-compat).
+ *
+ * omp 18.3.2 removed the path-based Settings API (`settings.override(path, value)`
+ * / `settings.clearOverride(path)`) in favour of registry handles: a handle
+ * carries the setting's identity — `handle.override(settings, value)` writes the
+ * runtime overlay and clearing goes through
+ * `settings.clearOverrideValue(handle)` (equivalent to
+ * `handle.clearOverride(settings)`). Every path-based call this plugin made
+ * (`clearOverride('modelRoles')`, `override('task.agentModelOverrides', …)`,
+ * `override('providers.maxInFlightRequests', …)`,
+ * `override('edit.modelVariants', …)`) now throws
+ * (`settings.clearOverride is not a function`), which took down the whole
+ * `/pick-model` apply path and silently disabled the concurrency hot-apply.
+ *
+ * Handles live on deep host subpaths and are loaded LAZILY via dynamic
+ * `import()` — never a static import:
+ *  - this package's own dev dependency is older (18.1.2) and ships no such
+ *    subpaths, so a static import would break typecheck/build;
+ *  - the host's legacy-pi-compat redirect rewrites these specifiers to the
+ *    host's own module instances, which is the singleton the session reads
+ *    (a separately `require()`d copy would be a no-op target for writes).
+ *
+ * The specifiers MUST BE STRING LITERALS — `import('@oh-my-pi/pi-coding-agent/
+ * config/model-settings')` — never a computed/concatenated string. The host
+ * rewrites extension sources textually (it collects string-literal import
+ * references and swaps them for absolute host paths), so a runtime-built
+ * specifier is not seen by the rewriter and resolves natively against this
+ * package's own 18.1.2 copy, i.e. the handle silently stays `undefined` on
+ * exactly the hosts this adapter exists for. `types/host-settings-modules.d.ts`
+ * supplies the build-time declarations those literal specifiers need.
+ * Each specifier is attempted independently of the others and the result (hit
+ * or miss) is cached for the process lifetime, so a host without these
+ * subpaths pays each failed import exactly once.
+ *
+ * Every helper falls back to the path-based API when the handle is missing, so
+ * hosts <= 18.1 keep their previous behaviour byte-for-byte.
+ */
+
+/** Minimal host registry-handle surface (omp >= 18.3 settings API). */
+export interface HostSettingHandle {
+    /** Write this setting's runtime override (never persisted). */
+    override(settings: unknown, value: unknown): void;
+    /**
+     * Clear this setting's runtime override. Present on handles, but the
+     * documented clear path is `settings.clearOverrideValue(handle)`, so the
+     * adapter tries that first (see {@link clearModelRolesRuntimeOverride}).
+     */
+    clearOverride?(settings: unknown): void;
+}
+
+/** Resolved handle per setting this plugin touches; a miss stays `undefined`. */
+export interface HostSettingsHandles {
+    /** `cfgModelRoles` — `config/model-settings`. */
+    modelRoles?: HostSettingHandle;
+    /** `cfgTaskAgentModelOverrides` — `task/settings`. */
+    taskAgentModelOverrides?: HostSettingHandle;
+    /** `cfgProvidersMaxInFlightRequests` — `session/settings`. */
+    providersMaxInFlight?: HostSettingHandle;
+    /** `cfgEditModelVariants` — `edit/settings`. */
+    editModelVariants?: HostSettingHandle;
+}
+
+interface HandleSpec {
+    key: keyof HostSettingsHandles;
+    exportName: string;
+    /**
+     * Literal-specifier loader (see the header: a computed specifier would not
+     * be rewritten by the host loader). Dynamic, so an older host's missing
+     * subpath rejects instead of breaking module evaluation.
+     */
+    load: () => Promise<unknown>;
+}
+
+const HANDLE_SPECS: readonly HandleSpec[] = [
+    {
+        key: 'modelRoles',
+        exportName: 'cfgModelRoles',
+        load: () => import('@oh-my-pi/pi-coding-agent/config/model-settings'),
+    },
+    {
+        key: 'taskAgentModelOverrides',
+        exportName: 'cfgTaskAgentModelOverrides',
+        load: () => import('@oh-my-pi/pi-coding-agent/task/settings'),
+    },
+    {
+        key: 'providersMaxInFlight',
+        exportName: 'cfgProvidersMaxInFlightRequests',
+        load: () => import('@oh-my-pi/pi-coding-agent/session/settings'),
+    },
+    {
+        key: 'editModelVariants',
+        exportName: 'cfgEditModelVariants',
+        load: () => import('@oh-my-pi/pi-coding-agent/edit/settings'),
+    },
+];
+
+async function loadHandle(spec: HandleSpec): Promise<HostSettingHandle | undefined> {
+    try {
+        const mod = (await spec.load()) as Record<string, unknown> | null | undefined;
+        const candidate = mod?.[spec.exportName] as Partial<HostSettingHandle> | undefined;
+        if (candidate && typeof candidate.override === 'function') return candidate as HostSettingHandle;
+    } catch {
+        /* subpath absent on this host (<= 18.1) — the path-based fallback applies */
+    }
+    return undefined;
+}
+
+let handlesPromise: Promise<HostSettingsHandles> | null = null;
+let handlesForTest: HostSettingsHandles | null | undefined;
+
+/** Test-only seam: inject fake handles, bypassing the dynamic imports. */
+export function _setHandlesForTest(handles: HostSettingsHandles | null | undefined): void {
+    handlesForTest = handles;
+}
+
+/** Test-only seam: drop injected handles and any cached load. */
+export function _resetForTest(): void {
+    handlesForTest = undefined;
+    handlesPromise = null;
+}
+
+/**
+ * Handles of the running host, loaded once per process. A host that lacks the
+ * subpaths yields `{}` — cached, so the failed imports run exactly once.
+ */
+export function hostSettingsHandles(): Promise<HostSettingsHandles> {
+    if (handlesForTest !== undefined) return Promise.resolve(handlesForTest ?? {});
+    handlesPromise ??= (async () => {
+        const out: HostSettingsHandles = {};
+        await Promise.all(
+            HANDLE_SPECS.map(async (spec) => {
+                const handle = await loadHandle(spec);
+                if (handle) out[spec.key] = handle;
+            }),
+        );
+        return out;
+    })();
+    return handlesPromise;
+}
+
+/** Path-based Settings API on hosts <= 18.1. */
+interface PathSettings {
+    override?(path: string, value: unknown): void;
+    clearOverride?(path: string): void;
+}
+
+/** Handle-clearing Settings API on hosts >= 18.3. */
+interface HandleClearingSettings {
+    clearOverrideValue?(handle: unknown): void;
+}
+
+/** Shared write path: registry handle first, path-based `override` second. */
+async function writeOverride(
+    handleKey: keyof HostSettingsHandles,
+    legacyPath: string,
+    settings: unknown,
+    value: unknown,
+): Promise<boolean> {
+    const handle = (await hostSettingsHandles())[handleKey];
+    if (handle) {
+        handle.override(settings, value);
+        return true;
+    }
+    const legacy = typeof settings === 'object' && settings !== null ? (settings as PathSettings) : null;
+    if (legacy && typeof legacy.override === 'function') {
+        legacy.override(legacyPath, value);
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Clear the session-scoped `modelRoles` overlay.
+ *
+ * omp >= 18.3: `settings.clearOverrideValue(cfgModelRoles)` (falling back to
+ * `handle.clearOverride(settings)`). <= 18.1: `settings.clearOverride('modelRoles')`.
+ *
+ * Returns `false` when neither API is present — callers warn and keep writing
+ * (an absent *clear* API does not mean settings are unusable).
+ */
+export async function clearModelRolesRuntimeOverride(settings: unknown): Promise<boolean> {
+    const handle = (await hostSettingsHandles()).modelRoles;
+    if (handle) {
+        const clearing = typeof settings === 'object' && settings !== null
+            ? (settings as HandleClearingSettings)
+            : null;
+        if (clearing && typeof clearing.clearOverrideValue === 'function') {
+            clearing.clearOverrideValue(handle);
+            return true;
+        }
+        if (typeof handle.clearOverride === 'function') {
+            handle.clearOverride(settings);
+            return true;
+        }
+    }
+    const legacy = typeof settings === 'object' && settings !== null ? (settings as PathSettings) : null;
+    if (legacy && typeof legacy.clearOverride === 'function') {
+        legacy.clearOverride('modelRoles');
+        return true;
+    }
+    return false;
+}
+
+/** Write the `task.agentModelOverrides` neutralization (handle API, else path API). */
+export function applyAgentModelOverrides(
+    settings: unknown,
+    value: Record<string, string>,
+): Promise<boolean> {
+    return writeOverride('taskAgentModelOverrides', 'task.agentModelOverrides', settings, value);
+}
+
+/** Hot-apply the complete `providers.maxInFlightRequests` map (handle API, else path API). */
+export function overrideProviderMaxInFlight(
+    settings: unknown,
+    value: Record<string, number>,
+): Promise<boolean> {
+    return writeOverride('providersMaxInFlight', 'providers.maxInFlightRequests', settings, value);
+}
+
+/** Pin `edit.modelVariants` at runtime (handle API, else path API). */
+export function overrideEditModelVariants(
+    settings: unknown,
+    value: Record<string, string>,
+): Promise<boolean> {
+    return writeOverride('editModelVariants', 'edit.modelVariants', settings, value);
+}

package/lib/model-roles.ts

@@ -17,13 +17,16 @@
  * commit/tiny via enumeration fallbacks terminating at smol, task via
  * primary-session inheritance, plan as a graceful no-op, advisor via the
  * static slow chain, custom roles via the config layer. The landing sequence
- * is unchanged: clearOverride('modelRoles') → overrideModelRoles(payload) →
- * empty-string neutralization of persisted per-agent pins.
+ * is unchanged: clear the modelRoles session overlay → overrideModelRoles(payload)
+ * → empty-string neutralization of persisted per-agent pins (the clear and the
+ * neutralization go through `lib/host-settings-adapter.ts`: registry handles on
+ * omp >= 18.3, path-based settings calls before that).
  */
 import { type ModelRole } from '@oh-my-pi/pi-coding-agent/config/model-roles';
 import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
 import type { SelectionContext } from '../index.js';
 import type { TierName } from './model-tiers.js';
+import { applyAgentModelOverrides, clearModelRolesRuntimeOverride } from './host-settings-adapter.js';
 import { OPSX_AGENTS } from './unified-config.js';
 
 /** Per-agent names written into `task.agentModelOverrides` neutralization. */
@@ -138,8 +141,8 @@ export function resolveOmpRoleTier(
  * Build the minimal write-set overlay plan (design D5): for each role in
  * `OMP_WRITE_SET_ROLES`, resolve its tier (or `skip`), apply capability
  * gating, then assign the single picked model for the tier. Roles without a
- * pick are recorded with a reason and omitted from the payload — after
- * `clearOverride` they fall back to the user's config layer (or stay
+ * pick are recorded with a reason and omitted from the payload — after the
+ * pre-clear they fall back to the user's config layer (or stay
  * unconfigured). Roles outside the write set are never iterated.
  */
 export function buildRoleOverridePlan(input: BuildRoleOverridePlanInput): RoleOverridePlan {
@@ -226,11 +229,26 @@ export function agentOverrideNeutralization(): Record<string, string> {
     return neutral;
 }
 
-/** Minimal Settings surface this module needs (host-process `pi.pi.settings`). */
+/**
+ * Minimal Settings surface this module needs (host-process `pi.pi.settings`).
+ *
+ * Deliberately a union of both host generations: `overrideModelRoles` (the
+ * session overlay write) exists in every version, while clearing and the
+ * path-based writes moved from `clearOverride(path)` / `override(path, value)`
+ * (<= 18.1) to registry handles (`clearOverrideValue(handle)`, see
+ * `lib/host-settings-adapter.ts`) in 18.3. Optional members keep every
+ * generation assignable; `applyRoleModelOverrides` never assumes a method
+ * exists.
+ */
 export interface RoleSettings {
-    clearOverride(key: string): void;
+    /** Session overlay write (limited to `{smol, default, slow, vision}` by the plan). */
     overrideModelRoles(roles: Record<string, string>): void;
-    override(key: string, value: unknown): void;
+    /** omp <= 18.1: clear the `modelRoles` runtime overlay by path. */
+    clearOverride?(key: string): void;
+    /** omp >= 18.3: clear a runtime overlay through its registry handle. */
+    clearOverrideValue?(handle: unknown): void;
+    /** omp <= 18.1: path-based runtime override. */
+    override?(key: string, value: unknown): void;
 }
 
 /**
@@ -243,25 +261,36 @@ export interface RoleSettings {
  * picked model are omitted and fall back to the config layer after the
  * clear) → neutralize persisted per-agent pins with empty strings. Never writes
  * disk; the runtime overlay is released with the session.
+ *
+ * Async because clearing/writing goes through `lib/host-settings-adapter.ts`,
+ * whose host handles are loaded by dynamic import; every call site awaits.
+ * Clearing and the neutralization write degrade to a warn when this host
+ * offers neither API generation — the missing *clear* is not a reason to skip
+ * the overlay write itself (the plan payload still applies).
  */
-export function applyRoleModelOverrides(
+export async function applyRoleModelOverrides(
     settings: RoleSettings | null | undefined,
     sel: SelectionContext,
     warn: (msg: string) => void = () => {},
-): void {
+): Promise<void> {
     if (!settings) {
         warn('[omp-opsx-addon] pi.pi.settings unavailable; model role overrides skipped');
         return;
     }
-    settings.clearOverride('modelRoles');
+    if (!(await clearModelRolesRuntimeOverride(settings))) {
+        warn('[omp-opsx-addon] no settings API to clear the modelRoles session overlay (host handles and path-based clearOverride both unavailable); writing the overlay without a pre-clear — stale roles from a previous selection may linger');
+    }
     settings.overrideModelRoles(sel.roleOverrides);
-    settings.override('task.agentModelOverrides', agentOverrideNeutralization());
+    const neutralized = await applyAgentModelOverrides(settings, agentOverrideNeutralization());
+    if (!neutralized) {
+        warn('[omp-opsx-addon] no settings API for task.agentModelOverrides (host handles and path-based override both unavailable)');
+    }
     const applied = Object.keys(sel.roleOverrides);
     const skippedText = sel.skippedRoles.length > 0
         ? `; skipped: ${sel.skippedRoles.map((s) => `${s.role}(${s.reason})`).join(', ')}`
         : '';
     const skipWarns = sel.skippedRoles.filter((s) => s.reason !== 'skip');
-    warn(`[omp-opsx-addon] modelRoles applied (${applied.length} roles: ${applied.join(', ') || 'none'})${skippedText}; per-agent pins neutralized`);
+    warn(`[omp-opsx-addon] modelRoles applied (${applied.length} roles: ${applied.join(', ') || 'none'})${skippedText}; per-agent pins ${neutralized ? 'neutralized' : 'NOT neutralized'}`);
     for (const s of skipWarns) {
         if (s.reason === 'capability') {
             warn(`[omp-opsx-addon] model role "${s.role}": no capable model in selection; skipped (role keeps configured/default value; change selector/allowlist or set model_role_tiers.${s.role}: skip)`);

package/lib/model-selector.ts

@@ -130,7 +130,11 @@ export function candidateQuota(
     const win = health.windows.find((w) => w.id === bucket) ?? health.windows.find((w) => w.id === 'other');
     const ondemand = health.windows.find((w) => w.id === 'ondemand');
     if (!win) {
-        return { exhausted: health.exhausted, remainingFraction: health.worstRemainingFraction };
+        // D6: provider-level exhaustion was relaxed for slow-pool cursor; the
+        // !win fallback must NOT get more permissive than pre-change behavior.
+        const cls = health.cursorLimitStatus;
+        const slowPoolAlive = !!cls && (cls.isInSlowPool || cls.grantsRemainingCents > 0);
+        return { exhausted: health.exhausted || slowPoolAlive, remainingFraction: health.worstRemainingFraction };
     }
     if (win.exhausted) {
         if (ondemand && !ondemand.exhausted) {

package/lib/usage-poller.ts

@@ -56,6 +56,7 @@ import { homedir } from 'os';
 import type { UsageReport } from '@oh-my-pi/pi-ai';
 import type { AuthStorageLike, ProviderHealth, DirectFetcher, ApiKeyResolver } from './usage-resolver.js';
 import { resolveProviderReports, buildHealthMap, canonicalizeProvider, listDetectableProviders } from './usage-resolver.js';
+import { fetchCursorLimitStatus, enhanceCursorReport } from './cursor-limit-status.js';
 import { RedisRelay } from './usage-redis-probe.js';
 import type { RedisTransport } from './usage-redis-client.js';
 import type { UsageBucket } from './usage-estimator.js';
@@ -979,8 +980,16 @@ async function fetchProvider(
         lastFetchedByProvider.set(canonical, fetchedAt);
         // Replace (or insert) just this provider's report; keep all others.
         const byId = new Map(cachedReports.map((r) => [r.provider, r]));
-        const newReport = reports.find((r) => r.provider === canonical);
+        let newReport = reports.find((r) => r.provider === canonical);
         if (newReport) {
+            // Cursor slow-pool/grants enhancement (D1): rides the existing fetch
+            // cadence; failure is fail-soft inside fetchCursorLimitStatus and must
+            // NOT re-mark dirty (the outer catch only guards the report fetch).
+            // On null the report lands as-is — current behavior (exhausted).
+            if (canonical === 'cursor') {
+                const limitStatus = await fetchCursorLimitStatus();
+                if (limitStatus) newReport = enhanceCursorReport(newReport, limitStatus);
+            }
             byId.set(canonical, newReport);
             // Fresh report landed → the provider's health is CONFIRMED.
             unconfirmedProviders.delete(canonical);

package/lib/usage-render.ts

@@ -42,6 +42,8 @@ export interface Painter {
     pct(p: number): string;
     /** Exhausted-window marker text, error-colored. */
     exhausted(text: string): string;
+    /** Warning / soft-degraded marker (e.g. Cursor ⚠降速), warning-colored. */
+    warning(text: string): string;
     /** Inter-column separator, already dyed incl. flanking spaces (3 cells). */
     sep: string;
     /** Provider header. `brandAnsi` is a raw brand-color SGR (or "" when none). */
@@ -101,6 +103,7 @@ export const ansiPainter: Painter = {
         return c(col === 'error' ? X : col === 'warning' ? Y : G, pctValue(p));
     },
     exhausted: (text) => c(X, text),
+    warning: (text) => c(Y, text),
     sep: ` ${D}│${R} `,
     header: (label, brandAnsi) => c(brandAnsi ? BOLD + brandAnsi : BOLD, label),
     balance: (text) => c(WHITE, text),
@@ -113,6 +116,7 @@ export function themePainter(theme: PainterTheme): Painter {
     return {
         pct: (p) => theme.fg(pctColor(p), pctValue(p)),
         exhausted: (text) => theme.fg('error', text),
+        warning: (text) => theme.fg('warning', text),
         sep: ` ${theme.fg('dim', '│')} `,
         header: (label, brandAnsi) => (brandAnsi ? c(brandAnsi, label) : theme.fg('accent', label)),
         balance: (text) => theme.fg('text', text),
@@ -135,6 +139,7 @@ const PROVIDER: Record<string, { label: string; color: string }> = {
     'kimi-code': { label: 'Kimi', color: CYAN },
     'minimax-code-cn': { label: 'MiniMax', color: X },
     'ark-coding-plan': { label: '火山方舟', color: CYAN },
+    'alibaba-token-plan': { label: '千问云', color: PURPLE },
     deepseek: { label: 'DeepSeek', color: BLUE },
     cursor: { label: 'Cursor', color: CYAN },
     'opencode-go': { label: 'OpenCode', color: G },
@@ -349,6 +354,30 @@ export const buildColumn = (r: UsageReport, painter: Painter = ansiPainter, load
         // column visible rather than dropping a logged-in provider.
         return isCursor ? [header, painter.balance('—')] : undefined;
     }
+    // Cursor slow-pool / grants markers (provider not exhausted — chips path).
+    // Status lives on its own line: bucket chips first, then ⚠降速 / Grants /
+    // reset countdown. No cursorLimitStatus note → single chips line, exactly
+    // as before the change.
+    if (isCursor && health.cursorLimitStatus) {
+        const cls = health.cursorLimitStatus;
+        const status: string[] = [];
+        if (cls.isInSlowPool) status.push(painter.warning('⚠降速'));
+        if (cls.grantsRemainingCents > 0) {
+            status.push(painter.balance(`Grants $${(cls.grantsRemainingCents / 100).toFixed(2)}`));
+        }
+        // Included buckets reset with the billing period — surface the soonest
+        // reset so a slow-pooled user can see when quota revives. Reuses the
+        // existing exhausted-path formatter; hidden when no resetsAt.
+        let soonest: number | undefined;
+        for (const l of r.limits) {
+            const at = l.window?.resetsAt;
+            if (typeof at !== 'number') continue;
+            soonest = soonest === undefined ? at : Math.min(soonest, at);
+        }
+        if (soonest !== undefined) status.push(`${resetIn(soonest)}重置`);
+        if (status.length === 0) return [header, parts.join(' · ')];
+        return [header, parts.join(' · '), status.join(' · ')];
+    }
     return [header, parts.join(' · ')];
 };
 

package/lib/usage-resolver.ts

@@ -13,6 +13,7 @@
  */
 
 import type { UsageReport, UsageStatus } from '@oh-my-pi/pi-ai';
+import { parseCursorLimitStatusNote, type CursorLimitStatus } from './cursor-limit-status.js';
 
 export type ApiKeyResolver = (provider: string) => Promise<string | undefined>;
 
@@ -100,6 +101,8 @@ export interface ProviderHealth {
     exhaustedWindows: string[];
     fetchedAt: number;
     notes?: string[];
+    /** Cursor slow-pool / grants echo (from `cursorLimitStatus=` note); render + selector consume this. */
+    cursorLimitStatus?: CursorLimitStatus;
 }
 
 const HEALTHY_REMAINING_THRESHOLD = 0.1;
@@ -262,6 +265,8 @@ export function summarizeReport(report: UsageReport): ProviderHealth {
 
     let exhausted = false;
     let worstRemaining: number | undefined;
+    const limitStatus =
+        report.provider === 'cursor' ? parseCursorLimitStatusNote(report.notes) : undefined;
 
     if (policy === 'bucket') {
         const byId = new Map(windows.map((w) => [w.id, w]));
@@ -277,6 +282,17 @@ export function summarizeReport(report: UsageReport): ProviderHealth {
             if (w.remaining === undefined) continue;
             if (worstRemaining === undefined || w.remaining > worstRemaining) worstRemaining = w.remaining;
         }
+        // D3: slow-pool / grants keep provider usable (warning) instead of exhausted.
+        if (
+            exhausted &&
+            limitStatus &&
+            (limitStatus.isInSlowPool || limitStatus.grantsRemainingCents > 0)
+        ) {
+            exhausted = false;
+            status = 'warning';
+        } else if (!exhausted && limitStatus?.isInSlowPool && status === 'ok') {
+            status = 'warning';
+        }
     } else if (policy === 'balance') {
         const win = windows[0];
         exhausted = windows.some((w) => w.exhausted) || (win?.remaining !== undefined && win.remaining <= 0);
@@ -315,6 +331,7 @@ export function summarizeReport(report: UsageReport): ProviderHealth {
         exhaustedWindows,
         fetchedAt: report.fetchedAt,
         notes: report.notes,
+        cursorLimitStatus: limitStatus,
     };
 }
 
@@ -327,7 +344,11 @@ export function healthCacheKey(health: Map<string, ProviderHealth> | null | unde
             const h = health.get(p)!;
             const wins = h.windows.map((w) => `${w.id}:${w.exhausted ? 1 : 0}:${w.remaining ?? ''}`).join(',');
             const ab = (h.autoBucketModels ?? []).join('+');
-            return `${p}=${h.exhausted ? 1 : 0};${wins};${ab}`;
+            // Cursor only: boolean bits (not raw cents) so grants churn does not invalidate selection cache.
+            const cls = h.cursorLimitStatus
+                ? `;sp=${h.cursorLimitStatus.isInSlowPool ? 1 : 0};g=${h.cursorLimitStatus.grantsRemainingCents > 0 ? 1 : 0}`
+                : '';
+            return `${p}=${h.exhausted ? 1 : 0};${wins};${ab}${cls}`;
         })
         .join('|');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genee/omp-opsx-addon",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "type": "module",
   "description": "Pi Extension: OpenSpec workflow orchestration - coder/reviewer/planner agents, session title & progress",
   "main": "./index.ts",

package/types/host-settings-modules.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Ambient declarations for the host Settings registry-handle subpaths
+ * (change: omp-18.3-settings-api-compat).
+ *
+ * `lib/host-settings-adapter.ts` must import these four modules with LITERAL
+ * specifiers: the host's legacy-pi-compat loader rewrites extension sources
+ * textually (it collects string-literal import/import() references and replaces
+ * them with absolute host paths), so a computed specifier would silently resolve
+ * against this package's own `@oh-my-pi/pi-coding-agent` dev dependency
+ * (18.1.2), which ships none of these subpaths.
+ *
+ * Literal specifiers, however, are resolved by `tsc` at build time — hence these
+ * declarations. Their shape mirrors the host's `Setting` handle: `override` is
+ * the write path, `clearOverride` is the (optional) clear path that
+ * `Settings.clearOverrideValue(handle)` performs.
+ */
+
+declare module '@oh-my-pi/pi-coding-agent/config/model-settings' {
+    /** Registered setting handle `modelRoles`. */
+    export const cfgModelRoles: {
+        override(settings: unknown, value: unknown): void;
+        clearOverride?(settings: unknown): void;
+    };
+}
+
+declare module '@oh-my-pi/pi-coding-agent/task/settings' {
+    /** Registered setting handle `task.agentModelOverrides`. */
+    export const cfgTaskAgentModelOverrides: {
+        override(settings: unknown, value: unknown): void;
+        clearOverride?(settings: unknown): void;
+    };
+}
+
+declare module '@oh-my-pi/pi-coding-agent/session/settings' {
+    /** Registered setting handle `providers.maxInFlightRequests`. */
+    export const cfgProvidersMaxInFlightRequests: {
+        override(settings: unknown, value: unknown): void;
+        clearOverride?(settings: unknown): void;
+    };
+}
+
+declare module '@oh-my-pi/pi-coding-agent/edit/settings' {
+    /** Registered setting handle `edit.modelVariants`. */
+    export const cfgEditModelVariants: {
+        override(settings: unknown, value: unknown): void;
+        clearOverride?(settings: unknown): void;
+    };
+}