@genee/omp-opsx-addon 0.12.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/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/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,7 @@ 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';
@@ -935,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.

package/lib/usage-render.ts

@@ -355,26 +355,26 @@ export const buildColumn = (r: UsageReport, painter: Painter = ansiPainter, load
         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.
+    // ⚠降速 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.isInSlowPool) status.push(painter.warning('⚠降速'));
         if (cls.grantsRemainingCents > 0) {
-            status.push(painter.balance(`Grants $${(cls.grantsRemainingCents / 100).toFixed(2)}`));
+            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. Reuses the
-        // existing exhausted-path formatter; hidden when no resetsAt.
+        // 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(`${resetIn(soonest)}重置`);
+        if (soonest !== undefined) status.push(painter.exhausted(resetIn(soonest)));
         if (status.length === 0) return [header, parts.join(' · ')];
         return [header, parts.join(' · '), status.join(' · ')];
     }
@@ -508,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

@@ -366,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;
 }
 
 /**
@@ -441,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
@@ -467,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.12.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;
+    };
 }