@genee/omp-opsx-addon 0.3.0 → 0.4.0

package/README.md

@@ -63,6 +63,15 @@ tiers:
 # 可选：role → tier 期望
 role_tiers:
   planner: top
+
+# 可选：OMP 内置/自定义 model role → tier 期望（或 skip 排除）
+# 仅影响 /pick-model 后 session 覆盖写入哪些模型；合法值 tiny/low/mid/high/top/skip
+model_role_tiers:
+  advisor: skip
+  plan: skip
+  tiny: skip
+  vision: skip   # vision 固定 high 档候选，仅 skip 有效（见下文）
+  task: low
 ```
 
 ---
@@ -73,6 +82,79 @@ role_tiers:
 
 决策日志打印到 stderr：`[omp-opsx-addon] planner → anthropic/claude-opus-4-6 (tier=top, gap=0, remaining=0.80)`
 
+
+### 子 agent 模型落点：session-scoped modelRoles
+
+`/pick-model <selector>` / `refresh` / `reset` 应用选择结果时，插件**不**再按 agent 名写
+`task.agentModelOverrides`，而是写 OMP session 运行时覆盖
+`settings.overrideModelRoles({ …全 role… })`——覆盖**宿主当前已知的全部 model role**
+（10 个内置 role + 自定义 role：`getKnownRoleIds` 从 cycleOrder/modelRoles/modelTags 汇总）：
+
+- 每个 role 跟随一个 tier 的选中模型；同一 tier 的多个 role 共用同一个模型（同候选集
+  排序结果唯一）。mid/high 复用 opsx 4 role 的选择（coder→mid、reviewer→high），
+  tiny/low/top 在同一过滤候选集上补选。
+- **内置 role 默认 tier 映射**：
+
+  | role | tier | 触发场景 |
+  | --- | --- | --- |
+  | `tiny` | tiny | 极小任务 |
+  | `smol` | mid | scout 等快速任务 |
+  | `task` | mid | task 工具委派的全能力子 agent（与 scout 同档，防能力倒挂） |
+  | `commit` | low | AI commit |
+  | `default` | high | 主会话 / reviewer |
+  | `designer` | high | designer agent |
+  | `vision` | high | `/vision`、图像输入（**能力门控**，见下） |
+  | `slow` | top | 深度思考 |
+  | `plan` | top | plan mode |
+  | `advisor` | top | advisor 会话 |
+
+  **激活语义**：advisor/plan/tiny 等默认未配置的 role 被写入覆盖后，**只在对应功能真正
+  触发时**（plan mode、advisor 会话、auto-thinking、AI commit、`/vision`）才会解析到
+  selector 模型；功能不触发就不产生消耗。覆盖 session 结束即还原。
+- **自定义 role**（cycleOrder/modelTags 里出现、不在内置表中的 role）默认跟随 `high`，
+  并一次性 warn 提示可用 `model_role_tiers` 调档或排除。
+- **`model_role_tiers`（opsx.yml）**：OMP role 名 → `tiny/low/mid/high/top` 或 `skip`，
+  覆盖上表默认值；自定义 role 也可配。`skip` 是唯一逃生舱——该 role **不写** session
+  覆盖、保留你的 config 值（默认策略是全量覆盖，包含 config 里的 `modelRoles.*` 钉值，
+  不做「自动跳过钉值」）。**例外：`vision` role 固定使用 high 档候选**（仅在具备 image
+  能力的模型中挑选，见下条），`model_role_tiers.vision` **仅 `skip` 生效**——配
+  `top/low/…` 等其他 tier 值会被静默接受但**不改变其选档**（仍按 high 档选图像模型）。
+  保守配置示例：
+
+  ```yaml
+  model_role_tiers:
+    advisor: skip   # 不想让 advisor 会话走 selector 模型
+    plan: skip      # plan mode 保留 config 钉值
+    tiny: skip      # 无 tiny 档模型时避免回落
+    vision: skip    # 不覆盖 vision（vision 固定 high 档选图像模型，仅 skip 有效）
+    task: low       # 显式降档
+  ```
+
+- **vision 能力门控**：vision 候选**固定按 high 档**、只从声明 `input` 含 `image` 的模型
+  中挑选（不按 `model_role_tiers.vision` 的 tier 值选档，该键仅 `skip` 有效）；当前选择里
+  没有图像模型时，vision role **不写覆盖**（warn 汇总为 `vision(capability)`，绝不写入
+  纯文本模型），vision 功能回落 config/default。恢复手段：换一个含图像模型的 selector
+  或用 `model_allowlist` 纳入图像模型；**`model_role_tiers.vision` 改 tier 绕不过门控、
+  也不改选档**。
+- **auto role 的 agent 定义**在 `.omp/agents/*.md` frontmatter 注入带引号的 tier alias
+  （coder `model: "@smol"`，其余三者 `model: "@default"`）；task 工具经 modelRoles 解析。
+- 因此**所有经 role 解析的 agent 都跟随切换**——包括插件未枚举的 OMP 内置/bundled/
+  project agent（例如内置 scout 走 `smol`，`/pick-model` selector/refresh/reset 后
+  scout 自动换到选中模型）。
+- auto role 与 omp-alias（如 `slow`，值无 `/`）的 dispatch 提示词**不传 `model=`**，
+  由 frontmatter alias 声明式接管；pinned 具体 provider/model 仍显式传 model，行为不变。
+- 某 tier 补选没有可用模型（候选耗尽/allowlist 全过滤）时，该 tier 的各 role 不写覆盖、
+  warn 汇总（`no-pick`），命令不中断；无任何模型时计划为空，与既有「模型注册表不可用」
+  分支一致。
+- 覆盖为 **session 作用域、不写盘**：`overrideModelRoles` 只写 runtime overlay，
+  session 结束即还原；不会修改你的 `~/.omp/agent/config.yml`。每次应用前先
+  `clearOverride('modelRoles')`，避免上一 selector 的旧 role 值残留；`reset` 重算无约束
+  默认并覆盖（**不清空**，否则回落 config 硬钉）。
+
+> **手动清理建议**：若全局 `~/.omp/agent/config.yml` 里有 `modelRoles.smol` 钉在会耗尽的
+> 套餐模型（scout 会一直打它直到被 session 覆盖压过），或 `task.agentModelOverrides` 残留
+> 已删除的 `tester` 等 key，可手动删除这些钉值；插件运行期间会以 session 空串中和 per-agent
+> 钉值，但不改动你的配置文件。
 ---
 
 ## 开发

package/index.ts

@@ -104,23 +104,36 @@ function handleSubagentEvent(payload: unknown, primarySessionId: string): void {
         sessionUsageRecorder.record(canonicalizeProvider(provider), usage, subagentStreamKey);
     } catch (err) {
         // Silently fail to avoid breaking the plugin
-        console.error('Failed to handle subagent event:', err);
+        getLogger().error('Failed to handle subagent event', { err });
     }
 }
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from '@oh-my-pi/pi-coding-agent';
+import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, Settings } from '@oh-my-pi/pi-coding-agent';
+import { getKnownRoleIds, MODEL_ROLE_IDS } from '@oh-my-pi/pi-coding-agent/config/model-roles';
 import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
 import type { UsageReport } from '@oh-my-pi/pi-ai';
 import { createCachedScanner } from './lib/change-scanner.js';
 import { installAgents } from './lib/agent-defs.js';
+import {
+    applyRoleModelOverrides,
+    buildRoleOverridePlan,
+    dispatchModelHint,
+    frontmatterModel,
+    ROLE_TO_OMP_ALIAS,
+    OMP_ROLE_TO_TIER,
+    ROLE_CAPABILITY,
+    type SkippedRole,
+} from './lib/model-roles.js';
 import { buildStaticPrompt, buildDynamicPrompt } from './lib/system-prompt.js';
 import { type ProviderHealth, canonicalizeProvider, listDetectableProviders, healthCacheKey } from './lib/usage-resolver.js';
 import { readOpsxSettings, type ResolvedOpsxConfig, type RoleValue, OPSX_ROLES } from './lib/unified-config.js';
-import { selectAllRoles, mergePlanProviders, type SelectorResult } from './lib/model-selector.js';
-import { scoreModelWithProvider } from './lib/model-tiers.js';
+import { selectAllRoles, selectModel, mergePlanProviders, type SelectorResult } from './lib/model-selector.js';
+import { scoreModelWithProvider, type TierName } from './lib/model-tiers.js';
 import { DIRECT_FETCHERS } from './lib/direct-fetchers.js';
 import { createUsageWidget } from './lib/usage-widget.js';
 import { renderUsageReports, type ConsumptionTrack } from './lib/usage-render.js';
 import { markExhausted, markAvailable, getExhaustedProviders } from './lib/provider-status.js';
+import { registerPipeCore } from './lib/pipe-core.js';
+import { registerPipePush } from './lib/pipe-push.js';
 import { scheduleStatusProbes } from './lib/status-probe.js';
 import {
     startSharedPoller,
@@ -158,6 +171,7 @@ import { filterSelectableModels, reachabilityFingerprint } from './lib/selection
 import { parseAutoModelArgs, CHINA_EXCLUDE_FAMILIES, listFamilies, listProviders } from './lib/family-filter.js';
 import { hasRateLimitError, hasRegionError, buildErrorDiagnosis, exclusionReasonStats } from './lib/error-scan.js';
 import { applyEditVariantPin } from './lib/edit-variant-pin.js';
+import { setOpsxLogger, getLogger } from './lib/logger.js';
 type Role = 'coder' | 'reviewer' | 'planner' | 'proposal-reviewer';
 
 /** Session-scoped selector constraint for `/pick-model <selector> [--china]`. */
@@ -266,24 +280,17 @@ export interface SelectionContext {
     roleModels: Record<Role, string | undefined>;
     /** Display label for each role from config, e.g. "auto", "smol", "deepseek-v4-pro". */
     roleConfigs: Record<Role, string | undefined>;
+    /** Parsed role value kind for each role (auto | omp-alias | model | provider-model). */
+    roleKind: Record<Role, RoleValue['kind']>;
+    /** Full-role session overlay payload written to `overrideModelRoles` (all known OMP roles). */
+    roleOverrides: Record<string, string>;
+    /** Known roles left out of the overlay payload (config skip / capability gate / no pick). */
+    skippedRoles: SkippedRole[];
 }
 
 const DEFAULT_PLAN_PROVIDERS = new Set(['minimax-code-cn', 'opencode-go', 'zhipu-coding-plan', 'kimi', 'openai-codex']);
 
-/** OPSX role → OMP role alias used in agent frontmatter `model: @<alias>`. */
-const ROLE_TO_OMP_ALIAS: Record<Role, string> = {
-    coder: 'smol',
-    reviewer: 'default',
-    planner: 'default',
-    'proposal-reviewer': 'default',
-};
 
-/** OMP role alias → expected tier (without the `@`). */
-const OMP_ROLE_TO_TIER: Record<string, string> = {
-    smol: 'mid',
-    default: 'high',
-    slow: 'top',
-};
 
 function roleValueToModelString(value: RoleValue): string | undefined {
     if (value.kind === 'auto') return undefined;
@@ -314,19 +321,39 @@ function synthPinnedResult(role: string, modelString: string | undefined): Selec
 export function buildDispatchPrompt(role: Role, task: string, selection: SelectionContext): string {
     const agent = AGENT_MAP[role];
     const sel = selection.selectorResults[role];
-    const modelHint = sel?.picked ? `${sel.picked.provider}/${sel.picked.id}` : selection.roleModels[role];
-    const parts = [`你的 opsx.${role} 已自动选择 model。`];
+    // auto roles (and omp-alias roles such as @slow) pass NO model: requestModel
+    // is the top-priority resolution layer and would shadow the frontmatter
+    // tier-role alias. Only concrete provider/model pins stay explicit.
+    const modelHint = dispatchModelHint(role, selection);
+    const parts = [`你的 opsx.${role} 模型由 role 自动解析。`];
     if (modelHint) parts.push(`请通过 task 工具调用 ${agent} 并指定 model="${modelHint}"。`);
-    else parts.push(`请通过 task 工具调用 ${agent}。`);
+    else parts.push(`请直接通过 task 工具调用 ${agent}（无需指定 model，模型按 role 自动解析）。`);
     if (sel?.decision) parts.push(`原因: ${sel.decision}`);
     parts.push('直接用内置工具实现。');
     return `请使用 task 工具委派给 ${agent}：\ntask(agent:"${agent}"${modelHint ? `, model:"${modelHint}"` : ''}, task:"${parts.join(' ')}\\n\\n${task}")`;
 }
 
+/**
+ * All model roles the host currently knows (10 built-in + custom roles from
+ * cycleOrder/modelRoles/modelTags). Host settings can throw during early
+ * startup or partial init; fall back to the built-in set rather than
+ * aborting selection (later recomputes pick up custom roles once ready).
+ */
+function safeGetKnownRoleIds(settings: Settings | null | undefined): string[] {
+    if (!settings) return [...MODEL_ROLE_IDS];
+    try {
+        return getKnownRoleIds(settings);
+    } catch (err) {
+        getLogger().warn(`[omp-opsx-addon] getKnownRoleIds failed; using built-in model roles only: ${err instanceof Error ? err.message : String(err)}`);
+        return [...MODEL_ROLE_IDS];
+    }
+}
+
 function computeSelectionSync(
     config: ResolvedOpsxConfig,
     models: Model<Api>[] | null,
     health: Map<string, ProviderHealth> | null,
+    knownRoleIds: string[],
     regionBlockedModels?: Set<string>,
     unreachableProviders?: Set<string>,
     availableByProvider?: Map<string, string[] | null>,
@@ -348,16 +375,23 @@ function computeSelectionSync(
     const selectorResults = {} as Record<Role, SelectorResult>;
     const roleModels = {} as Record<Role, string | undefined>;
     const roleConfigs = {} as Record<Role, string | undefined>;
+    const roleKind = {} as Record<Role, RoleValue['kind']>;
     const planSet = mergePlanProviders(config.planProviders);
     for (const role of OPSX_ROLES) {
         const value = config.roles[role];
-        roleConfigs[role] = value.kind === 'auto' ? ROLE_TO_OMP_ALIAS[role] : (roleValueToModelString(value) ?? '?');
+        roleKind[role] = value.kind;
+        // Config label shown in /pick-model choices markdown (`角色 (label)`):
+        // auto roles display the OMP tier-role alias; pinned roles the pin.
+        roleConfigs[role] = value.kind === 'auto'
+            ? ROLE_TO_OMP_ALIAS[role]
+            : (roleValueToModelString(value) ?? '?');
         const alias = `@${ROLE_TO_OMP_ALIAS[role]}`;
         if (value.kind === 'auto') {
             if (filteredModels && filteredModels.length > 0) {
                 const ompRole = ROLE_TO_OMP_ALIAS[role];
-                const tier = (config.roleTiers[role] ?? OMP_ROLE_TO_TIER[ompRole] ?? 'mid') as
-                    'top' | 'high' | 'mid' | 'low' | 'tiny';
+                const tier = (config.roleTiers[role]
+                    ?? (OMP_ROLE_TO_TIER as Record<string, TierName>)[ompRole]
+                    ?? 'mid') as TierName;
                 const roleTiers = { ...config.roleTiers, [role]: tier };
                 const result = selectAllRoles(
                     [role],
@@ -388,9 +422,56 @@ function computeSelectionSync(
             roleModels[role] = modelString?.includes('/') ? modelString : undefined;
         }
     }
-    return { selectorResults, roleModels, roleConfigs };
+    // change: pick-model-batch-all-roles — build the full-role session overlay:
+    // every host-known role (10 built-in + custom) follows one tier's picked
+    // model. mid/high reuse the opsx picks (coder/reviewer); tiny/low/top are
+    // supplemental picks over the same filtered candidate set; vision picks
+    // from image-capable candidates only. See design D2/D3.
+    let roleOverrides: Record<string, string> = {};
+    let skippedRoles: SkippedRole[] = [];
+    if (filteredModels && filteredModels.length > 0) {
+        const pickString = (r: SelectorResult): string | undefined =>
+            r.picked ? `${r.picked.provider}/${r.picked.id}` : undefined;
+        const tierPicks: Partial<Record<TierName, string | undefined>> = {
+            mid: pickString(selectorResults.coder),
+            high: pickString(selectorResults.reviewer),
+        };
+        for (const supplementalTier of ['tiny', 'low', 'top'] as const) {
+            const synthRole = `__tier_${supplementalTier}`;
+            const result = selectModel({
+                role: synthRole,
+                models: filteredModels,
+                roleTiers: { [synthRole]: supplementalTier },
+                tierOverrides: config.tierOverrides,
+                health: health ?? undefined,
+                allowlist: config.modelAllowlist,
+                planProviders: planSet,
+            });
+            tierPicks[supplementalTier] = pickString(result);
+        }
+        const capabilityPicks: Record<string, string | undefined> = {};
+        const visionModels = filteredModels.filter((m) => ROLE_CAPABILITY.vision(m));
+        if (visionModels.length > 0) {
+            const visionResult = selectModel({
+                role: 'vision',
+                models: visionModels,
+                roleTiers: { vision: 'high' },
+                tierOverrides: config.tierOverrides,
+                health: health ?? undefined,
+                allowlist: config.modelAllowlist,
+                planProviders: planSet,
+            });
+            capabilityPicks.vision = pickString(visionResult);
+        }
+        const plan = buildRoleOverridePlan(
+            { knownRoleIds, ompRoleTiers: config.ompRoleTiers, tierPicks, capabilityPicks },
+            (m) => getLogger().warn(m),
+        );
+        roleOverrides = plan.overrides;
+        skippedRoles = plan.skipped;
+    }
+    return { selectorResults, roleModels, roleConfigs, roleKind, roleOverrides, skippedRoles };
 }
-
 function formatModelChoicesMarkdown(sel: SelectionContext, suffix: string = '', primaryModel?: Model<Api>): string {
     const rows: string[] = [];
     let totalModelCount = 0;
@@ -481,6 +562,9 @@ const sessionUsageRecorder: SessionUsageRecorder = createSessionUsageRecorder({
 // ── plugin entry ────────────────────────────────────────────────────
 
 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);
     // 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
@@ -492,7 +576,11 @@ export default (pi: ExtensionAPI) => {
     // host reads the merged view directly, making the file equivalent.
     applyEditVariantPin(pi, { 'deepseek-v4-flash': 'replace' });
     const directory = process.cwd();
-    const warn = (msg: string) => console.warn(msg);
+    const warn = (msg: string) => pi.logger.warn(msg);
+    // Roles known to the host at the moment of a (re)selection: computed per
+    // call so custom roles appearing after startup are covered on
+    // refresh/reset/selector/tick.
+    const currentKnownRoleIds = (): string[] => safeGetKnownRoleIds(pi.pi?.settings);
     const opsxConfig = readOpsxSettings(directory, warn);
     // Static orchestration rules — built once, reused every turn for cache stability.
     const STATIC_PROMPT = buildStaticPrompt();
@@ -583,6 +671,7 @@ export default (pi: ExtensionAPI) => {
                 effectiveConfig,
                 models,
                 health,
+                currentKnownRoleIds(),
                 regionBlockedModels,
                 reach.unreachable,
                 reach.availableByProvider,
@@ -596,30 +685,16 @@ export default (pi: ExtensionAPI) => {
         });
         return selectionPromise;
     };
-    // Push selector-picked models to native task subagents via task.agentModelOverrides.
-    // pi.pi.settings is the host-process Settings singleton (the require()'d copy in
-    // node_modules is a separate, uninitialized instance — writing to it was a no-op).
-    const applyAgentModelOverrides = (sel: SelectionContext, force = false): void => {
-        const settings = pi.pi?.settings;
-        if (!settings) {
-            warn('[omp-opsx-addon] pi.pi.settings unavailable; subagent model overrides skipped');
-            return;
-        }
-        const overrides: Record<string, string> = {};
-        for (const role of OPSX_ROLES) {
-            const picked = sel.selectorResults[role]?.picked;
-            if (picked) {
-                overrides[AGENT_MAP[role]] = `${picked.provider}/${picked.id}`;
-            }
-        }
-        if (Object.keys(overrides).length > 0 || force) {
-            settings.override('task.agentModelOverrides', overrides);
-            warn(
-                `[omp-opsx-addon] task.agentModelOverrides: ${Object.entries(overrides)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join(', ')}`,
-            );
-        }
+    // Apply selector picks by TIER to session-scoped OMP modelRoles (smol =
+    // coder/mid, default = reviewer/high), so every role-resolving agent —
+    // including built-in scout (smol) — follows selector/refresh/reset.
+    // Persisted per-agent pins are neutralized at runtime with empty strings.
+    // pi.pi.settings is the host-process Settings singleton (the require()'d
+    // 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);
     };
 
     // ── shared usage poller + widget ──────────────────────────────
@@ -980,7 +1055,12 @@ export default (pi: ExtensionAPI) => {
             // This fallback call is intentionally NOT threaded with familyConstraint:
             // it prefers the cached `selection`, and the fallback passes models=null so
             // filterSelectableModels' family branch never runs — it is not a reselect path.
-            const sel = selection ?? computeSelectionSync(opsxConfig, null, null);
+            const sel = selection ?? computeSelectionSync(
+                opsxConfig,
+                null,
+                null,
+                safeGetKnownRoleIds(pi.pi?.settings),
+            );
             const changes = await changeScanner.scanChanges(directory, 'doing');
             // Layered injection: STATIC_PROMPT is byte-identical every turn → prefix cache
             // hit for [omp-base + skills + static]. Only the dynamic tail re-prefills.
@@ -994,17 +1074,14 @@ export default (pi: ExtensionAPI) => {
 
     pi.on('session_start', async (_event, ctx) => {
         try {
-            const pinned = (role: Role): string | undefined => {
-                const v = opsxConfig.roles[role];
-                if (v.kind === 'auto') return undefined;
-                return roleValueToModelString(v);
-            };
+            const frontmatter = (role: Role): string | undefined =>
+                frontmatterModel(role, opsxConfig.roles[role]);
             await installAgents(
                 directory,
-                pinned('coder'),
-                pinned('reviewer'),
-                pinned('planner'),
-                pinned('proposal-reviewer'),
+                frontmatter('coder'),
+                frontmatter('reviewer'),
+                frontmatter('planner'),
+                frontmatter('proposal-reviewer'),
             );
             warn('[omp-opsx-addon] agents ready (pick-model idle until /pick-model refresh)');
         } catch (e) {
@@ -1020,7 +1097,7 @@ export default (pi: ExtensionAPI) => {
         const getApiKey = ctx.modelRegistry?.getApiKeyForProvider
             ? (provider: string) => ctx.modelRegistry.getApiKeyForProvider(provider)
             : undefined;
-        // 429/403 is the only observable exhaustion evidence for providers
+        // Provider exhaustion seen on the response/tool path; mark it locally
         // without a usage fetcher — record it in the process-local binary status
         // so the placeholder column reads 耗尽 (see lib/provider-status.ts).
         markExhausted(canonical);
@@ -1119,6 +1196,7 @@ export default (pi: ExtensionAPI) => {
                         effectiveConfig,
                         models,
                         health,
+                        currentKnownRoleIds(),
                         regionBlockedModels,
                         reach.unreachable,
                         reach.availableByProvider,
@@ -1154,7 +1232,7 @@ export default (pi: ExtensionAPI) => {
                         }
                     }
                     selection = freshSel;
-                    applyAgentModelOverrides(freshSel);
+                    applyRoleModel(freshSel);
                     if (changes.length > 0) {
                         pi.sendMessage({ customType: 'pick-model', content: `✅ 模型已刷新:\n${changes.join('\n')}`, display: true }, { triggerTurn: false });
                     } else {
@@ -1181,6 +1259,7 @@ export default (pi: ExtensionAPI) => {
                         effectiveConfig,
                         models,
                         health,
+                        currentKnownRoleIds(),
                         regionBlockedModels,
                         reach.unreachable,
                         reach.availableByProvider,
@@ -1205,7 +1284,7 @@ export default (pi: ExtensionAPI) => {
                     if (newPrimary) await pi.setModel(newPrimary);
                     selection = sel;
                     selectionHealthKey = buildSelectionHealthKey(health, reach, familyConstraint);
-                    applyAgentModelOverrides(sel, true);
+                    applyRoleModel(sel);
                     pi.sendMessage({
                         customType: 'pick-model',
                         content: changes.length > 0
@@ -1265,6 +1344,7 @@ export default (pi: ExtensionAPI) => {
                         effectiveConfig,
                         models,
                         health,
+                        currentKnownRoleIds(),
                         regionBlockedModels,
                         reach.unreachable,
                         reach.availableByProvider,
@@ -1324,7 +1404,7 @@ export default (pi: ExtensionAPI) => {
                     if (newPrimary) await pi.setModel(newPrimary);
                     selection = sel;
                     selectionHealthKey = buildSelectionHealthKey(health, reach, familyConstraint);
-                    applyAgentModelOverrides(sel);
+                    applyRoleModel(sel);
                     const content = `✅ 已切换 selector 约束 (${formatFamilyConstraint(familyConstraint)}):\n${changes.join('\n')}${hint ? `\n${hint}` : ''}`;
                     pi.sendMessage({
                         customType: 'pick-model',
@@ -1379,4 +1459,14 @@ export default (pi: ExtensionAPI) => {
         if (selection) return selection;
         return ensureSelection(ctx);
     }
+
+    // Cross-broker project-scoped pipe core: registers opsx_pipe_list /
+    // _send / _recv / _wait and starts presence heartbeat + GC on
+    // session_start (managed timers inside lib/pipe-core).
+    registerPipeCore(pi);
+
+    // Cross-broker push/injector: watches the local mbox slot and injects
+    // inbound pipe messages as custom (opsx-pipe) turns; /opsx-pipe mute
+    // toggles the stop-injection flag (managed timers inside lib/pipe-push).
+    registerPipePush(pi);
 };

package/lib/agent-defs.ts

@@ -5,7 +5,7 @@ const MARKER = '<!-- @genee/omp-opsx-addon -->';
 const CODE_REVIEWER_MD = (model?: string) => `---
 name: code-reviewer
 description: OpenSpec 代码审查 agent，审查代码实现并执行全局验证
-tools: read, bash, glob, grep${model ? `\nmodel: ${model}` : ''}
+tools: read, bash, glob, grep${model ? `\nmodel: "${model}"` : ''}
 ---
 
 你是一位资深代码审查员。你根据 OpenSpec 提案和设计文档审查代码实现，并在审阅的同时执行最后一次全局验证。
@@ -71,7 +71,7 @@ ${MARKER}
 const PROPOSAL_REVIEWER_MD = (model?: string) => `---
 name: proposal-reviewer
 description: OpenSpec 提案审查 agent，审查提案质量
-tools: read, bash, glob, grep${model ? `\nmodel: ${model}` : ''}
+tools: read, bash, glob, grep${model ? `\nmodel: "${model}"` : ''}
 ---
 
 你是一位资深需求审查员。你审查 OpenSpec 提案的完整性和质量。
@@ -123,7 +123,7 @@ ${MARKER}
 const CODER_MD = (model?: string) => `---
 name: coder
 description: OpenSpec 变更实现 agent，同步 tasks.md 进度
-tools: read, write, edit, bash, glob, grep, todo${model ? `\nmodel: ${model}` : ''}
+tools: read, write, edit, bash, glob, grep, todo${model ? `\nmodel: "${model}"` : ''}
 skill: openspec-apply-change
 ---
 
@@ -184,7 +184,7 @@ ${MARKER}
 const PLANNER_MD = (model?: string) => `---
 name: planner
 description: OpenSpec 提案规划 agent
-tools: read, write, edit, bash, glob, grep, todo${model ? `\nmodel: ${model}` : ''}\nskill: openspec-propose
+tools: read, write, edit, bash, glob, grep, todo${model ? `\nmodel: "${model}"` : ''}\nskill: openspec-propose
 ---
 
 你是一个 OpenSpec 提案规划 agent。负责创建和更新 OpenSpec 变更提案文档。

package/lib/edit-variant-pin.ts

@@ -117,7 +117,7 @@ export function applyEditVariantPin(pi: ExtensionAPI, pin: Record<string, string
         | { override(path: string, value: unknown): void; getAgentDir?: () => string }
         | undefined;
     if (!settings) {
-        console.warn('[omp-opsx-addon] pi.pi.settings unavailable; edit variant pin skipped');
+        pi.logger?.warn('[omp-opsx-addon] pi.pi.settings unavailable; edit variant pin skipped');
         return;
     }
 
@@ -139,18 +139,18 @@ export function applyEditVariantPin(pi: ExtensionAPI, pin: Record<string, string
 
         const configPath = resolveGlobalConfigPath(agentDir);
         if (!configPath) {
-            console.warn(
+            pi.logger?.warn(
                 `[omp-opsx-addon] edit variant pin failed: no global config.yml found under ${agentDir}`,
             );
             return;
         }
         const outcome = persistEditVariantPin(configPath, pin);
         if (outcome === 'written') {
-            console.warn(
+            pi.logger?.warn(
                 `[omp-opsx-addon] edit variant pin persisted to ${configPath} (effective from the next session)`,
             );
         }
     } catch (err) {
-        console.warn('[omp-opsx-addon] edit variant pin failed:', err);
+        pi.logger?.warn('[omp-opsx-addon] edit variant pin failed', { err });
     }
 }

package/lib/logger.ts

@@ -0,0 +1,33 @@
+/**
+ * 插件日志通道（模块级注入）。
+ *
+ * 主进程日志不再走 console.*（会在 omp TUI 里打爆界面），改走宿主
+ * pi.logger（滚动文件日志）。lib 模块拿不到 pi 对象，故提供模块级 holder：
+ * 入口 setOpsxLogger(pi.logger) 注入，lib 侧 getLogger() 读取。
+ * 未注入（测试场景直接调用叶子函数）时默认 console，输出与迁移前一致。
+ */
+
+/** 窄化日志接口：宿主 pi.logger 与 console 的结构交集，仅本插件使用的四级方法。 */
+export interface OpsxLogger {
+  error(message: string, context?: Record<string, unknown>): void;
+  warn(message: string, context?: Record<string, unknown>): void;
+  info(message: string, context?: Record<string, unknown>): void;
+  debug(message: string, context?: Record<string, unknown>): void;
+}
+
+/** 模块级当前 logger，默认 console（未注入/测试场景保持旧行为）。 */
+let current: OpsxLogger = console;
+
+/** 插件入口注入宿主 pi.logger（进程级单例，多实例重复注入幂等）。
+ *  空值注入忽略：保持 getLogger() 恒可用（console 兜底）——测试 mock 的
+ *  pi 对象可能不含 logger，此时视同未注入，输出与迁移前一致。 */
+export function setOpsxLogger(logger: OpsxLogger): void {
+  if (logger) {
+    current = logger;
+  }
+}
+
+/** 读取当前 logger。 */
+export function getLogger(): OpsxLogger {
+  return current;
+}