@genee/omp-opsx-addon 0.11.0 → 0.13.0

package/index.ts

@@ -112,8 +112,9 @@ import {
     roleKindLabel,
     tierLabel,
 } from './lib/pick-model-render.js';
+import { primeSymbolPresetReader } from './lib/host-settings-adapter.js';
 import { buildStaticPrompt, buildDynamicPrompt } from './lib/system-prompt.js';
-import { type ProviderHealth, canonicalizeProvider, listDetectableProviders, healthCacheKey } from './lib/usage-resolver.js';
+import { type ProviderHealth, canonicalizeProvider, listDetectableProviders, healthCacheKey, loggedInProviderIds } from './lib/usage-resolver.js';
 import { readOpsxSettings, resolveManagedProviders, type ResolvedOpsxConfig, type AgentValue, OPSX_AGENTS } from './lib/unified-config.js';
 import {
     createConcurrencyController,
@@ -905,6 +906,9 @@ export default (pi: ExtensionAPI) => {
     // Route plugin logging through the host logger (rolling file) instead of
     // console.*, which would corrupt the TUI. Injected before any log path runs.
     setOpsxLogger(pi.logger);
+    // Prime the 18.5+ `cfgSymbolPreset` read handle (fire-and-forget lazy
+    // import); /pick-model renders read it synchronously via resolveSymbols.
+    primeSymbolPresetReader();
     // Runtime edit-variant pin for deepseek-v4-flash. The host hard-maps the
     // model to the sloppy §/» marker grammar (it misreads hashline ranges),
     // but the model repeatedly breaks sloppy control lines too — retry loops
@@ -1305,10 +1309,10 @@ export default (pi: ExtensionAPI) => {
                     /* modelRegistry unavailable → fall back to auth.list() + detectable */
                 }
                 try {
-                    if (auth?.list) {
+                    const loggedInIds = loggedInProviderIds(auth);
+                    if (loggedInIds) {
                         authAvailable = true;
-                        const list = auth.list();
-                        const ids = Array.isArray(list) ? list : [];
+                        const ids = Array.isArray(loggedInIds) ? loggedInIds : [];
                         loggedIn = [...new Set([...loggedIn, ...ids.map(canonicalizeProvider)])];
                     }
                 } catch {

package/lib/concurrency-multiproc.worker.ts

@@ -59,6 +59,13 @@ import {
     type WriterFileSystemPort,
 } from './concurrency-writer.js';
 import { RedisClient } from './usage-redis-client.js';
+import { _setHandlesForTest as setHostHandles } from './host-settings-adapter.js';
+
+// This harness records hot-applies through the plugin's path-based
+// SettingsPort contract (`override(path, value)`); neutralize the host
+// registry handles for the whole worker process so the adapter's 18.5
+// handle path cannot intercept those recorded calls.
+setHostHandles({});
 
 // ── wire protocol ───────────────────────────────────────────────────────────
 

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/host-settings-adapter.ts

@@ -118,6 +118,8 @@ export function _setHandlesForTest(handles: HostSettingsHandles | null | undefin
 export function _resetForTest(): void {
     handlesForTest = undefined;
     handlesPromise = null;
+    symbolPresetHandle = undefined;
+    symbolPresetLoadStarted = false;
 }
 
 /**
@@ -139,6 +141,65 @@ export function hostSettingsHandles(): Promise<HostSettingsHandles> {
     return handlesPromise;
 }
 
+/** Minimal read surface of a host registry `Setting` handle. */
+interface SettingReaderHandle {
+    get(settings: unknown): unknown;
+}
+
+/**
+ * Read-only handle for the host `symbolPreset` setting.
+ *
+ * omp 18.5.0 moved `pi.pi.settings` from a key-based handle
+ * (`settings.get('symbolPreset')`) to the raw `Settings` instance, where
+ * reads go through registered `Setting` objects — `cfgSymbolPreset` on
+ * `modes/settings`. As with the write handles above, the subpath is loaded
+ * lazily via a LITERAL dynamic import and primed fire-and-forget at
+ * extension init; the sync reader below falls back to the legacy key read
+ * until (and on hosts where) the handle never lands.
+ */
+let symbolPresetHandle: SettingReaderHandle | undefined;
+let symbolPresetLoadStarted = false;
+
+/** Kick off the lazy `modes/settings` import (no await; sync reads follow). */
+export function primeSymbolPresetReader(): void {
+    if (symbolPresetLoadStarted) return;
+    symbolPresetLoadStarted = true;
+    void import('@oh-my-pi/pi-coding-agent/modes/settings')
+        .then((mod: Record<string, unknown> | null | undefined) => {
+            const candidate = mod?.cfgSymbolPreset as Partial<SettingReaderHandle> | undefined;
+            if (candidate && typeof candidate.get === 'function') {
+                symbolPresetHandle = candidate as SettingReaderHandle;
+            }
+        })
+        .catch(() => {
+            /* subpath absent on this host — the legacy key read applies */
+        });
+}
+
+/**
+ * Synchronous `symbolPreset` read across host generations: the 18.5+
+ * registry handle first, then the <= 18.4 key-based settings object.
+ * `undefined` when neither shape can answer — callers keep their fallback.
+ */
+export function readSymbolPreset(settings: unknown): unknown {
+    if (symbolPresetHandle) {
+        try {
+            return symbolPresetHandle.get(settings);
+        } catch {
+            /* not a host Settings instance (e.g. a test stub) — try the
+             * legacy key read below before giving up */
+        }
+    }
+    const legacy = typeof settings === 'object' && settings !== null
+        ? (settings as { get?(key: string): unknown })
+        : null;
+    try {
+        return legacy?.get?.('symbolPreset');
+    } catch {
+        return undefined;
+    }
+}
+
 /** Path-based Settings API on hosts <= 18.1. */
 interface PathSettings {
     override?(path: string, value: unknown): void;

package/lib/model-roles.ts

@@ -13,10 +13,12 @@
  * `model_role_tiers`), feeds it the single picked model for that tier, and
  * records skip reasons (`skip` config sentinel, capability gate such as
  * vision/image, or no picked model for the tier). Roles outside the write set
- * resolve through OMP native chains: designer via default inheritance,
- * 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
+ * resolve through OMP native chains (omp 18.5.0 inheritance table):
+ * tiny/memory via the always-on chain (tiny→smol, memory→tiny→smol),
+ * commit via enumeration fallbacks terminating at smol, task via
+ * primary-session inheritance, plan as a graceful no-op, advisor via slow
+ * only when slow is explicitly configured, custom roles via the config
+ * layer. The landing sequence
  * 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
@@ -50,18 +52,28 @@ export const ROLE_TO_OMP_ALIAS: Record<string, string> = {
  * table to cover every built-in role. Entries outside the write set stay
  * relevant as the tier-key source for role-scope slot resolution
  * (`scopedTierSlots`), which may point any scope role at its slot.
+ *
+ * omp 18.5.0 role set: `designer` was removed; `memory` plus the kind roles
+ * (`image`/`web`/`speech`/`dictation`/`judge`) were added. Kind roles are
+ * never in the write set — their entries exist only so the exhaustive
+ * `satisfies` clause holds and `scopedTierSlots` finds a tier key.
  */
 export const OMP_ROLE_TO_TIER = {
     tiny: 'tiny',
     smol: 'mid',
     task: 'mid',
+    memory: 'mid',
     commit: 'low',
     default: 'high',
-    designer: 'high',
     vision: 'high',
     slow: 'top',
     plan: 'top',
     advisor: 'top',
+    image: 'mid',
+    web: 'mid',
+    speech: 'mid',
+    dictation: 'mid',
+    judge: 'top',
 } satisfies Record<ModelRole, TierName>;
 
 /**

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/pick-model-render.ts

@@ -20,14 +20,18 @@
  * Everything here is a pure function; index.ts assembles the parts and
  * calls `renderPickModelReport` once per command output.
  */
-import { SYMBOL_PRESETS, isValidSymbolPreset } from '@oh-my-pi/pi-coding-agent/modes/theme/symbols';
+import { SYMBOL_PRESETS, isValidSymbolPreset } from '@oh-my-pi/pi-tui/theme/symbols';
 import type { AgentDefinition } from '@oh-my-pi/pi-coding-agent/task/types';
 import { providerDisplayName } from './provider-variants.js';
+import { readSymbolPreset } from './host-settings-adapter.js';
 
-/** Minimal settings surface for the `symbolPreset` read (host `pi.pi.settings`). */
-export interface SymbolSettings {
-    get(key: string): unknown;
-}
+/**
+ * Settings value passed to the `symbolPreset` read (host `pi.pi.settings`):
+ * the key-based handle on hosts <= 18.4; the 18.5+ raw `Settings` instance is
+ * read through the registry handle in the adapter. Both shapes are
+ * duck-typed there, so the parameter is an opaque `unknown`.
+ */
+export type SymbolSettings = unknown;
 
 /** Internal glyph set used by every pick-model output (design D2). */
 export interface RenderSymbols {
@@ -51,14 +55,13 @@ export interface RenderSymbols {
  * Read the current preset per render; undefined/invalid — or a settings
  * read that throws (early startup / partial init) — falls back to unicode
  * without ever surfacing an error into a command output.
+ *
+ * `settings` accepts both host generations: the key-based handle (<= 18.4)
+ * and the raw `Settings` instance (18.5+, read through the registry
+ * `cfgSymbolPreset` handle primed by `primeSymbolPresetReader` in index.ts).
  */
 export function resolveSymbols(settings?: SymbolSettings | null): RenderSymbols {
-    let raw: unknown;
-    try {
-        raw = settings?.get('symbolPreset');
-    } catch {
-        raw = undefined;
-    }
+    const raw = readSymbolPreset(settings);
     const preset = typeof raw === 'string' && isValidSymbolPreset(raw) ? raw : 'unicode';
     const map = SYMBOL_PRESETS[preset];
     return {
@@ -131,12 +134,14 @@ export interface AgentModelSource {
 }
 
 /**
- * Classify an agent by its frontmatter `model` patterns (design D4 table).
- * Missing / `default` / `@default` / `@task` → inherit the primary session
- * model; `@smol`/`@slow` follow the written roles; `@designer` follows via
- * default inheritance; `@tiny`/`@advisor` resolve OMP static priority chains
- * (unless config-pinned, which always wins over the label); literal patterns
- * are pins; other `@role` values stay on the config layer.
+ * Classify an agent by its frontmatter `model` patterns (design D4 table,
+ * omp 18.5.0 semantics). Missing / `default` / `@default` / `@task` →
+ * inherit the primary session model; `@smol`/`@slow` follow the written
+ * roles; `@tiny` follows via the always-on smol inheritance, `@memory`
+ * via tiny→smol (host inheritance table); `@advisor` follows the slow
+ * chain only while slow is explicitly configured (pick-model's write set
+ * covers slow, so after an apply it follows); literal patterns are pins;
+ * other `@role` values stay on the config layer.
  */
 export function classifyAgentModelSource(model?: string[]): AgentModelSource {
     const first = model?.find((m) => typeof m === 'string' && m.trim() !== '')?.trim();
@@ -146,11 +151,14 @@ export function classifyAgentModelSource(model?: string[]): AgentModelSource {
     if (first === '@smol' || first === '@slow') {
         return { label: `role 链 ${first}`, follows: true };
     }
-    if (first === '@designer') {
-        return { label: 'role 链 @designer（经 default 继承）', follows: true };
+    if (first === '@tiny') {
+        return { label: 'role 链 @tiny（经 smol 继承）', follows: true };
+    }
+    if (first === '@memory') {
+        return { label: 'role 链 @memory（经 tiny→smol 继承）', follows: true };
     }
-    if (first === '@tiny' || first === '@advisor') {
-        return { label: `OMP 自动链 ${first}（静态 priority 模式）`, follows: false };
+    if (first === '@advisor') {
+        return { label: 'role 链 @advisor（经 slow 继承，slow 配置时）', follows: true };
     }
     if (first.startsWith('@')) {
         return { label: `自定义 role ${first}`, follows: false };

package/lib/unified-config.ts

@@ -9,8 +9,10 @@
  *
  * Accepted values for each dispatch agent:
  *   - `'auto'` — let the model-selector pick based on tier + usage.
- *   - An OMP role alias: `default`, `smol`, `slow`, `vision`, `plan`,
- *     `designer`, `commit`, `tiny`, `task`, `advisor` — expanded by the
+ *   - An OMP role alias (any entry of the host `MODEL_ROLE_IDS` list —
+ *     currently `default`, `smol`, `slow`, `vision`, `plan`, `commit`,
+ *     `tiny`, `memory`, `task`, `advisor`, `image`, `web`, `speech`,
+ *     `dictation`, `judge`) — expanded by the
  *     OMP `modelRoles` setting (not by this plugin) to a concrete model.
  *   - A concrete model id: `gpt-5`, `claude-opus-4-6`.
  *   - A provider-scoped selector: `anthropic/claude-opus-4-6`,
@@ -29,7 +31,7 @@
  *     rename to `agent_tiers:`. Affected agents fall back to `auto`.
  *   - `model_role_tiers`: `omp_role → tier_name | 'skip'` map controlling
  *     which selector tier each OMP model role (default/smol/slow/vision/plan/
- *     designer/commit/tiny/task/advisor + custom roles) follows after
+ *     commit/tiny/memory/task/advisor + kind roles + custom roles) follows after
  *     /pick-model; `skip` excludes the role from the session overlay.
  *     Disambiguation: those are the OMP host *model roles*, not the four
  *     opsx dispatch agents configured via `agents` / `agent_tiers`.
@@ -50,21 +52,17 @@ import { canonicalizeProvider } from './usage-resolver.js';
 import { DEFAULT_MIN_SAMPLES, SPEED_MODES, type SpeedAwareConfig, type SpeedMode } from './model-speed.js';
 import { QUALITY_PREFERENCES, type QualityPreference, type RoutingConfig } from './complexity-router.js';
 import { DEFAULT_THRESHOLD, DEFAULT_WINDOW, type StallEscalationConfig } from './stall-detector.js';
+import { MODEL_ROLE_IDS } from '@oh-my-pi/pi-coding-agent/config/model-roles';
 import { DEFAULT_WEIGHT, type ContinuityGuardConfig } from './continuity-guard.js';
-
-/** OMP-documented role aliases. Plugins MAY pass these to `task(..., model: '@alias')`. */
-export const OMP_ROLE_ALIASES = new Set<string>([
-    'default',
-    'smol',
-    'slow',
-    'vision',
-    'plan',
-    'designer',
-    'commit',
-    'tiny',
-    'task',
-    'advisor',
-]);
+/**
+ * OMP-documented role aliases. Plugins MAY pass these to
+ * `task(..., model: '@alias')`. Derived from the host's canonical
+ * `MODEL_ROLE_IDS` list (omp 18.5.0: designer removed; memory + kind roles
+ * added), so the accepted-alias set cannot drift from the running host.
+ */
+export const OMP_ROLE_ALIASES: Record<string, true> = Object.fromEntries(
+    MODEL_ROLE_IDS.map((role) => [role, true as const]),
+);
 
 /** Special "let the plugin decide" marker. */
 export const AUTO_TOKEN = 'auto';
@@ -289,7 +287,7 @@ export function parseAgentValue(raw: string | undefined, _warn: (msg: string) =>
         _warn(`[omp-opsx-addon] legacy "${trimmed}" → "${legacyStripped}" (pi:/local: prefix no longer needed)`);
         return parseAgentValue(legacyStripped, _warn);
     }
-    if (OMP_ROLE_ALIASES.has(trimmed.toLowerCase())) {
+    if (OMP_ROLE_ALIASES[trimmed.toLowerCase()]) {
         return { kind: 'omp-alias', alias: trimmed.toLowerCase() };
     }
     const { provider, modelId } = splitProviderModel(trimmed);

package/lib/usage-poller.ts

@@ -55,7 +55,8 @@ import { join, dirname, extname } from 'path';
 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 { resolveProviderReports, buildHealthMap, canonicalizeProvider, listDetectableProviders, loggedInProviderIds } 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';
@@ -934,8 +935,9 @@ function getLoggedInProviders(
     directFetchers: DirectFetcher[],
 ): string[] {
     const detectable = listDetectableProviders(directFetchers);
-    if (authStorage?.list) {
-        return [...new Set([...authStorage.list().map(canonicalizeProvider), ...detectable])];
+    const loggedIn = loggedInProviderIds(authStorage);
+    if (loggedIn) {
+        return [...new Set([...loggedIn.map(canonicalizeProvider), ...detectable])];
     }
     // No authStorage (tests / offline): direct fetchers' providers are the universe,
     // with detectable probes still honored when present.
@@ -979,8 +981,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).
+    // ⚠降速 joins the bucket chips on the first line; 赠金 and the reset
+    // countdown live on a second status line (countdown in the error color).
+    // No cursorLimitStatus note → single chips line, exactly as before.
+    if (isCursor && health.cursorLimitStatus) {
+        const cls = health.cursorLimitStatus;
+        if (cls.isInSlowPool) parts.push(painter.warning('⚠降速'));
+        const status: string[] = [];
+        if (cls.grantsRemainingCents > 0) {
+            status.push(painter.balance(`赠金 $${(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. Bare
+        // countdown, error-colored; 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(painter.exhausted(resetIn(soonest)));
+        if (status.length === 0) return [header, parts.join(' · ')];
+        return [header, parts.join(' · '), status.join(' · ')];
+    }
     return [header, parts.join(' · ')];
 };
 
@@ -479,6 +508,19 @@ export function renderUsageReports(
     const valid = cols.filter((c) => c.col.length > 0);
     if (valid.length === 0) return [];
 
+    // Status-row parity: the cursor slow-pool block carries a third text row
+    // (⚠降速 / Grants / reset countdown). When ANY block has it, pad every
+    // other block with a blank status row so the per-block consumption
+    // waveform (pushed below) starts on the same line across the whole bar —
+    // otherwise the charts sit one row apart. Without any status row the
+    // output stays byte-identical to the two-row layout.
+    const STATUS_ROW = 2;
+    if (valid.some((c) => c.col.length > STATUS_ROW)) {
+        for (const c of valid) {
+            while (c.col.length <= STATUS_ROW) c.col.push('');
+        }
+    }
+
     for (const c of valid) {
         // Per-provider consumption waveform at the FIXED WAVEFORM_COLS width:
         // every chart renders 20 Braille columns regardless of the block's

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('|');
 }
@@ -345,14 +366,51 @@ export function buildHealthMap(reports: UsageReport[]): Map<string, ProviderHeal
     return map;
 }
 
-/** Minimal interface for the auth-storage call site we depend on. */
+/**
+ * Structural view of the host auth storage (`ctx.modelRegistry.authStorage`)
+ * across host generations. omp <= 18.4 exposed the bulk fetch and the
+ * logged-in listing as top-level methods; 18.5.0 regrouped them behind
+ * namespace getters (`usage.reports()`, `credentials.list()`). Both shapes
+ * are optional so one interface serves either generation, and the shared
+ * `usage`/`credentials` member names keep host instances assignable.
+ */
 
 export interface AuthStorageLike {
+    /** omp <= 18.4: top-level bulk fetch. */
     fetchUsageReports?: (params?: { signal?: AbortSignal }) => Promise<UsageReport[] | undefined | null>;
-    /** List all providers with credentials configured. */
+    /** omp 18.5+: namespaced bulk fetch. */
+    usage?: { reports?: (options?: { signal?: AbortSignal }) => Promise<UsageReport[] | null> };
+    /** omp <= 18.4: logged-in provider ids. */
     list?: () => string[];
-    /** Check if a specific provider has any auth configured. */
-    hasAuth?: (provider: string) => boolean;
+    /** omp 18.5+: credential rows namespace. */
+    credentials?: {
+        list?: (provider?: string) => { provider: string }[];
+        has?: (provider: string) => boolean;
+    };
+}
+
+/**
+ * Bulk-fetch usage reports from whichever generation the host storage
+ * exposes. Returns the promise to await, or `undefined` when neither shape
+ * is present (tests / offline — callers proceed with direct fetchers only).
+ */
+export function bulkFetchUsageReports(
+    storage: AuthStorageLike | undefined,
+    signal?: AbortSignal,
+): Promise<UsageReport[] | null | undefined> | undefined {
+    if (storage?.fetchUsageReports) return storage.fetchUsageReports({ signal });
+    if (storage?.usage?.reports) return storage.usage.reports({ signal });
+    return undefined;
+}
+
+/**
+ * Logged-in provider ids from whichever generation the host storage
+ * exposes; `undefined` when no listing is available.
+ */
+export function loggedInProviderIds(storage: AuthStorageLike | undefined): string[] | undefined {
+    if (storage?.list) return storage.list();
+    const rows = storage?.credentials?.list?.();
+    return rows ? rows.map((row) => row.provider) : undefined;
 }
 
 /**
@@ -420,7 +478,8 @@ async function gatherReports(
     // `zai-coding-cn` a fetcher returns, so dedup/override keys are stable).
     const directFetcherByProvider = new Map(directFetchers.map((f) => [canonicalizeProvider(f.provider), f]));
     const directIds = new Set(directFetcherByProvider.keys());
-    const loggedInSet = authStorage?.list ? new Set(authStorage.list().map(canonicalizeProvider)) : null;
+    const loggedInIds = loggedInProviderIds(authStorage);
+    const loggedInSet = loggedInIds ? new Set(loggedInIds.map(canonicalizeProvider)) : null;
 
     // Classify target providers into direct (have a fetcher) vs bulk (need
     // fetchUsageReports). `bulkTargets === null` means "discover via bulk" — used
@@ -446,10 +505,13 @@ async function gatherReports(
     // Step 1: bulk fetchUsageReports — ONLY when there are bulk targets to fetch.
     // A direct-fetcher provider never triggers this. Discovery mode (null) calls
     // bulk unconditionally but excludes providers that have direct fetchers.
-    if (authStorage?.fetchUsageReports && (bulkTargets === null || bulkTargets.length > 0)) {
+    // The capability check runs BEFORE the fetch promise is created.
+    const hasBulkFetch = Boolean(authStorage?.fetchUsageReports ?? authStorage?.usage?.reports);
+    if (hasBulkFetch && (bulkTargets === null || bulkTargets.length > 0)) {
+        const bulkFetch = bulkFetchUsageReports(authStorage, signal);
         const filterSet = bulkTargets ? new Set(bulkTargets) : null;
         try {
-            const fetched = await authStorage.fetchUsageReports({ signal });
+            const fetched = await bulkFetch;
             if (Array.isArray(fetched)) {
                 for (const r of fetched) {
                     // Canonicalize BEFORE filtering so a login-name id merges

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genee/omp-opsx-addon",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "description": "Pi Extension: OpenSpec workflow orchestration - coder/reviewer/planner agents, session title & progress",
   "main": "./index.ts",
@@ -38,13 +38,15 @@
   "peerDependencies": {
     "@oh-my-pi/pi-agent-core": ">=17.0.7",
     "@oh-my-pi/pi-coding-agent": ">=17.0.7",
+    "@oh-my-pi/pi-tui": ">=17.0.7",
     "@oh-my-pi/pi-utils": ">=17.0.7",
     "typebox": ">=0.34.0"
   },
   "devDependencies": {
     "@oh-my-pi/pi-coding-agent": ">=17.0.7",
+    "@oh-my-pi/pi-tui": ">=17.0.7",
     "@oh-my-pi/pi-utils": ">=17.0.7",
-    "@types/node": "^24.13.3",
+    "@types/node": "^24.19.1",
     "typebox": ">=0.34.0",
     "typescript": "^5.9.3"
   }

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

@@ -45,4 +45,10 @@ declare module '@oh-my-pi/pi-coding-agent/edit/settings' {
         override(settings: unknown, value: unknown): void;
         clearOverride?(settings: unknown): void;
     };
+}
+declare module '@oh-my-pi/pi-coding-agent/modes/settings' {
+    /** Registered setting handle `symbolPreset` (read-only use). */
+    export const cfgSymbolPreset: {
+        get(settings: unknown): unknown;
+    };
 }