@mars.liu/dsh-cybernetics 0.25.2 → 0.25.5

package/README.md

@@ -172,7 +172,7 @@ The settings card's「预置方案」dropdown — ten options: **auto-recommend*
 - **Vendor entries (data-driven, `status: 'ready'`)**: each vendor carries per-role model + reasoning-effort token (heterogeneous: OpenAI/Minimax five-level low/medium/high/xhigh/max, DeepSeek thinking switch, others model default), upgrade tier, availability fallback, per-role rationale, per-vendor note (⚠️ caveats — e.g. Qwen's 「verify 绝不用 Turbo」幻觉共振 warning, Kimi's K2-retirement avoidance, DeepSeek's 「成本不应成为降级 verify 的理由」) and VARIANTS (Claude 常规/高要求, Qwen A/B/C, DeepSeek 仅本家/verify 外置, Kimi 长期/最高验收质量, 火山 A/B, GLM 标准组合/重活命名角色). Selecting a preset applies its **default variant** (the first one); the outcome record discloses the variant applied and lists the remaining ones. Vendor-canonical model ids are applied verbatim — an id absent from this deployment's catalog shows the card's model-unavailable warning and the round's availability fallback (v0.8) keeps rounds alive.
 - **Auto-recommend (since v0.18.2 = a session-agent handoff, user ruling)**: selecting auto runs **NO independent LLM call and spawns NO agent** (the previous one guarded one-shot LLM call plus its route config field were removed — re-submitting the whole context to a second model call is a waste of both time and money). The plugin now probes the live catalog (`probeCatalogOptions`, the same directory smart selection reads), builds the handoff brief — embedding the catalog (the only selectable source), the cross-vendor principles (verify ≥ task; verify/task kept cross-generation/cross-family independent; verify must not be over-confident; cost cuts hit task/triage first and never verify; triage light), the current role config and every vendor preset as advisory reference — writes a `pending` record to the card, and hands the brief to the session agent through the plugin-registered `preset_recommend` tool (a steer/followup reminder is delivered to live session agents). The SESSION AGENT reads the catalog in its OWN context, answers for task/verify/triage, and calls the same tool again to submit; the plugin only validates (catalog-matched models only; per-role `reasoningEffort` validated against `ctx.llm.resolveModelInfo` and dropped to the model default when unsupported) and writes. Until the session agent answers, the card shows the pending note; an unusable answer (off-catalog / unparseable / zero picks) degrades to a written `degraded` record with the reason and is reported back to the session agent for a corrected re-submission — nothing is applied and no round is blocked. The tool survives the hard-gate allowlist alongside the cybernetics tool itself.
 - **Selecting is one-shot**: re-selecting the same entry does not re-fire (the handler guards on the last handled value; a value persisted across a restart is not re-applied at boot). Switch to「（未选择）」first to re-apply an entry.
-- **`/cybernetics use [id]` (v0.22.0, command channel)**: switch the role composition to any preset plan without opening the settings card. With no argument the command replies with a plain-text list of every applicable plan — all built-in registry ids plus the configured custom presets (`custom:<id>`) — and asks the user to confirm with a second `/cybernetics use <id>`. With an id it reuses the SAME apply pipeline as the dropdown (`handlePresetSelection`, six-field-bounded ops + the outcome record), so the reply and the card stay consistent; preset ids are case-preserved (custom ids are matched verbatim). Unlike the dropdown, a repeated `use <id>` DOES re-apply the same plan (the command keeps the one-shot volatile guard in sync and deliberately bypasses it), so no「（未选择）」detour is needed. The preset applied this way is profile-global — it affects every concurrent session.
+- **`/cybernetics use [id]` (v0.22.0; session-only since v0.25.5, user ruling)**: switch the role composition of **THIS SESSION** to any preset plan without opening the settings card. With no argument the command replies with a plain-text list of every applicable plan — all built-in registry ids plus the configured custom presets (`custom:<id>`) — and asks the user to confirm with a second `/cybernetics use <id>`. With an id the resolved task/verify/triage picks (models + reasoning efforts) are stored in an **in-memory per-session override** (`src/sessionRoles.ts`) — **zero settings-service writes**: the six global role fields, the `presetPlan` selector and the `presetRecommendation` record are never touched. The round dispatch folds the override with "session override > global fields" precedence, per role and per field. The receipt states it explicitly: `已在本会话应用预置方案 "<label>"：task=... verify=... triage=...；仅本会话生效（会话结束失效），不修改全局配置`. A repeated `use <id>` (same or different plan) simply replaces the override; `/cybernetics use off` clears it and the session falls back to the global fields (the `status` reply carries the current override state and this clear command). To change the GLOBAL configuration use the settings card — note that its writes are subject to the host's Include write-gate defect (see the settings-card section); `use` deliberately takes no part in that path. `use auto` hands the auto-recommendation brief to THIS session's agent and lands the `preset_recommend` result as the session override too (the card's own auto path is unchanged).
 - **Editor-side preset picker (v0.24.1, popupSelect)**: the picker appears only after you express the `use` intent. Picking `/cybernetics` in the `/` menu completes the composer text to `/cybernetics` (no popup — keep typing `use ...`); pressing Enter on the bare `/cybernetics` token opens a searchable popup listing every applicable plan (the 12 built-in ids and the configured `custom:<id>` entries, grouped, fuzzy-filtered as you type, current plan highlighted); typing `/cybernetics use` and pressing Enter executes the plain-text listing and then opens the same popup over it. Picking a row runs `/cybernetics use <id>` through the same command transport (validation/apply/receipt stay server-authoritative; errors surface in the popup). This rides the host's own mechanism for commands with pickable values (`commandUi.decorate` + the public `popupFor`/`command/executed` faces, the same pattern as the official `/model` picker); hosts without the `commandUi` service keep the plain-text v0.22 behavior, and the typed `/cybernetics use <id>` path is untouched. Note: inline argument completion *inside the draft* (a dropdown right after typing `use `) is not possible with the host protocol — the slash trigger scan stops at the first whitespace (re-verified v0.25.0: the host composer publishes no draft-change event, the four `slash/input-*` scope events are plugin→shell bail-request channels only, and trigger-source outcomes are limited to `{claim}/{text}/{insert}` — nothing can observe the `/cybernetics use` draft before Enter). **Type `/cybernetics use`, then press Enter to open the preset picker** (the bare-enter path lands the plain-text listing first and the popup opens over it).
 
 ## Installation and Usage

package/README.zh-CN.md

@@ -172,7 +172,7 @@ goal 一经存在不再原地修改。`revise` 是唯一的改目标动词（必
 - **厂商方案（数据驱动，`status: 'ready'`）**：每厂商含逐角色模型 + 思考强度 token（异构：OpenAI/Minimax 五档 low/medium/high/xhigh/max、DeepSeek thinking 开关、其余模型默认）、可升级档、可用性 fallback、逐角色 rationale、厂商备注（⚠️ 注意事项——如 Qwen 的「verify 绝不用 Turbo（幻觉共振）」、Kimi 的避开退役 K2、DeepSeek 的「成本不应成为降级 verify 的理由」）与**多变体**（Claude 常规/高要求，Qwen A/B/C，DeepSeek 仅本家/verify 外置，Kimi 长期组合/最高验收质量，火山 A/B，GLM 标准组合/重活命名角色）。选择方案应用其**默认变体**（第一个）；结果记录披露所应用变体并列出其余变体。厂商原生模型 id 逐字应用——部署目录中不存在的 id 会显示卡片不可用警告，轮内可用性 fallback（v0.8）保证轮次存活。
 - **自动推荐（v0.18.2 起 = session agent 交办，用户裁定）**：选择 auto 时插件**不发起任何独立 LLM 调用、不新起任何子 agent**（v0.17.2 及之前的「一次一次性 LLM 调用 + 推荐所用模型配置项」已删除——另起一次调用等于把上下文重复提交一遍，时间与经济性都不合理）。现在的流程：插件探测实时目录（`probeCatalogOptions`，与智能选择同源），把推荐交办单——内嵌目录（唯一可选来源）、跨厂商通用原则（task/verify/triage 三角色可灵活配置，允许同款模型或任意档位组合；verify 不能过度自信；省成本先压 task/triage、verify 最后动且成本不是降级 verify 的理由；triage 轻量）、当前角色配置与全部厂商方案（仅作参考）——经插件注册的 `preset_recommend` 工具交给 session agent，并在卡片写入 `pending` 记录、向在线 session agent 投递一条 steer/followup 提醒。session agent 在**自己的上下文中**读取目录、给出 task/verify/triage 的答案，再次调用该工具提交；插件只负责校验（逐字命中目录；逐角色 `reasoningEffort` 经 `ctx.llm.resolveModelInfo` 校验，不支持时降为模型默认并注明）与写入。session agent 未作答时卡片保持 pending；答案不可用（未命中目录/不可解析/零选择）时降级为带原因的 `degraded` 记录并回执给 session agent 修正重交——不应用任何更改、不阻塞任何轮次。该工具在硬门禁 allowlist 下与 cybernetics 工具一同保留。
 - **选择是一次性的**：重复选择同一项不会再次触发（处理器按最后处理值守卫；跨重启持久化的值不会在启动时重放）。要重复应用某项，先切「（未选择）」再选。
-- **`/cybernetics use [方案id]`（v0.22.0，命令通道）**：不开设置卡片，直接把角色组合切换为任意预置方案。无参数时命令回执纯文本清单——全部内置方案 id + 已配置的自定义方案（`custom:<id>`）——并提示用户再次输入 `/cybernetics use <id>` 确认；带 id 时复用与下拉框完全相同的应用管线（`handlePresetSelection`：六字段白名单 ops + 结果记录），回执与卡片保持一致；方案 id 大小写保留（自定义 id 逐字匹配）。与下拉框不同，重复输入同一条 `use <id>` 会**再次应用**（命令路径同步维护一次性守卫 `lastHandledPresetPlan` 并刻意绕过它），无需先切「（未选择）」。此方式应用的方案为 profile 全局生效——影响所有并发会话。
+- **`/cybernetics use [方案id]`（v0.22.0；v0.25.5 起仅当前会话生效，用户裁定）**：不开设置卡片，把**本会话**的角色组合切换为任意预置方案。无参数时命令回执纯文本清单——全部内置方案 id + 已配置的自定义方案（`custom:<id>`）——并提示用户再次输入 `/cybernetics use <id>` 确认；带 id 时解析出的 task/verify/triage picks（模型 + 思考强度）存入**内存中的按会话覆盖表**（`src/sessionRoles.ts`）——**零 settings 写入**：六个全局角色字段、`presetPlan` 选择器、`presetRecommendation` 记录均不触碰。轮次派工按「会话覆盖 > 全局字段」逐角色逐字段合并。回执明确语义：`已在本会话应用预置方案 "<label>"：task=... verify=... triage=...；仅本会话生效（会话结束失效），不修改全局配置`。重复 `use <id>`（同方案或换方案）直接覆盖更新；`/cybernetics use off` 清除覆盖、回到全局字段（status 回执带当前覆盖状态与该清除指令）。修改**全局**配置请使用设置卡片——注意卡片的全局写入受宿主 Include 写闸门缺陷影响（见设置卡片章节）；`use` 刻意不参与该路径。`use auto` 把自动推荐 brief 交给本会话 agent，`preset_recommend` 结果同样落为会话覆盖（卡片自身的 auto 全局路径不变）。
 - **编辑器侧方案选择器（v0.24.1，popupSelect）**：选择器只在你表达 `use` 意图之后出现。在 / 菜单点选 `\cybernetics` 只把编辑器文本补全为 `/cybernetics`（不弹层——继续输入 `use ...` 即可）；对裸 `/cybernetics` 回车弹出可搜索的方案选择器（12 个内置 id 与已配置的 `custom:<id>` 条目分组列出，输入即模糊过滤，当前方案高亮）；键入 `\cybernetics use` 回车则先落地纯文本清单，随后同一弹层在其上弹出。点选一项即经同一条命令通道提交 `/cybernetics use <id>`（校验/应用/回执仍以服务端为唯一权威，错误就地显示在弹层）。实现走宿主为「带可选值的命令」提供的原生机制（`commandUi.decorate` + 公开的 `popupFor`/`command/executed` 面，与官方 `/model` 选择器同一模式）；宿主无 commandUi 服务时保持 v0.22 纯文本行为，键入路径 `/cybernetics use <id>` 完全不动。说明：草稿内的参数级补全（输入 `use ` 后就地弹下拉）在宿主协议下不可实现——斜杠触发扫描遇空格即止（v0.25.0 复核：宿主 composer 不对外发射任何草稿变更事件，四个 `slash/input-*` 作用域事件均为插件→shell 的 bail 请求通道，触发源 outcome 仅 `{claim}/{text}/{insert}` 三种，均无法在回车前感知 `/cybernetics use` 草稿）。**请输入 `/cybernetics use` 后按 Enter 唤起方案选择器**（无参回车先落地纯文本清单，弹层随即在其上出现）。
 
 ## 安装与使用

package/docs/CHANGELOG.md

@@ -4,6 +4,26 @@
 > 当下的功能与使用方式以 [README.md](../README.md) 为准；协议细节见 [protocol.md](protocol.md)。
 > 约定：`src/` 改动需宿主重载生效；`lib/client.js` 改动需重启宿主（客户端模块图在宿主启动时构建）并刷新浏览器；`workflows/round.js` 改动热生效。
 
+## v0.25.5（2026-11-11）：`/cybernetics use` 改为仅当前会话生效——零 settings 写入（用户裁定，推翻 v0.25.4 方向）
+
+**用户裁定（2026-11-11，最高优先级）**：`use` 一律实现为**仅当前会话生效**——完全不调用 settings mutate（不写六角色字段、不写 `presetPlan`、不写 `presetRecommendation`），不做「先全局再降级」。背景：宿主存在写闸门缺陷（v0.7.10：dsh-app-boot 双模块实例 → WeakMap miss → 所有 settings 写入被拒 "profile reload requires the root Include entry"），某些启动方式下 v0.22–v0.25.4 的全局写路径完全无效。
+
+- **实现**：新增 `src/sessionRoles.ts`——进程内存中的按会话角色覆盖表（`{preset, label, roles: {task/verify/triage: {provider, model, reasoningEffort}}, appliedAt}`），参考 `sessionMode.ts` 的会话级覆盖模式但不做任何持久化（随宿主进程/会话生命周期消失）。`use <id>` 解析方案（内置 id / `custom:<id>`）后把 picks 存入覆盖表；轮次派工读取点（src/index.ts 平铺字段折叠处）按「会话覆盖 > 全局字段」逐角色逐字段合并（`mergeSessionRolesOverride`）。
+- **auto**：`use auto` 走会话管道——标记会话 pending 并把 brief 交给本会话 agent，`preset_recommend` 工具第二跳校验后把推荐落为**会话覆盖**（strip 到 provider/model/reasoningEffort），全程零 settings 写入；设置卡片自身的 auto 全局路径（下拉框 → pending 记录 → 全局写）完全不动。
+- **清除**：`/cybernetics use off` 清除覆盖回到全局字段；status 回执新增「会话预置方案覆盖」行（无覆盖显示「无（跟随全局配置）」，有覆盖显示 label + picks + 清除指令）。
+- **回执**：`已在本会话应用预置方案 "<label>"：task=... verify=... triage=...；仅本会话生效（会话结束失效），不修改全局配置`。无参数清单、未知方案报错行为保留。
+- **清理**：`writePresetRecord` / `handlePresetSelection` 的 `extraOps` 参数与 use 分支的 `presetPlan` 同步 op 一并移除（v0.25.4 的全局同步属于被推翻方向）；卡片路径行为不变；`ALLOWED_OP_PATHS` 未放宽。
+- **诊断**：`presetDiag` 新增 `event:'use-session-apply'`（preset、label、picks、cleared），use 路径不再出现任何 `write-*` 事件。
+- **测试**：`test/v23-use-subcommand.mjs` 重写为会话语义——use 后零 settings mutate（pin）、覆盖含 effort 被 merge 语义取到（pin）、重复 use 更新、`use off` 恢复、status 含覆盖行、`use auto` 落会话不落全局（含 degraded/rejected 也零写入）。全部通过；`tsc --noEmit` 真实错误 0（TS5097 基线噪音除外）。
+
+## v0.25.4（2026-11-11，已被 v0.25.5 推翻）：`/cybernetics use` 应用后同步设置卡片「预置方案」下拉框
+
+**变更**：`/cybernetics use <id>` 之前只把 task/verify/triage 的模型与思考强度字段写入 settings（模型配置已生效并持久化），但不写 volatile 选择器 `presetPlan`，导致配置界面的预置方案下拉框停留在旧方案。现在 `use` 分支给 `handlePresetSelection`（→ `writePresetRecord` 新增可选 `extraOps` 参数）传入一条 `{op:'set', path:['presetPlan'], value:<id>}`，与六字段 ops + 结果记录在**同一次 mutate** 中原子写入（内置 id、`auto`、`custom:<id>` 均同步）。失败/degraded/placeholder 结果不经过 extraOps 调用点——下拉框保持原值；未知方案在命令层即报错、零写入。one-shot 守卫保持一致：写入触发的 loader volatile-update 回环中 `plan === lastHandledPresetPlan` → `willHandle=false`，不会重复应用（测试 6/6b 已 pin）；重复 `use` 同一方案仍可重复应用；设置卡片自身选择路径不变；`ALLOWED_OP_PATHS` 六字段白名单未放宽。测试 `test/v23-use-subcommand.mjs` 更新并新增 6/6b/6c 三个断言组，全部通过。
+
+## v0.25.3（2026-11-10）：消除 dshmarket 静态巡检对 `custom:` 自定义方案选择器的误报（纯代码形态修正，无功能变化）
+
+**变更**：`lib/client.js` 两处形态修正——①方案选择器 `custom:` 前缀拼接改为数组 `join`（行为等价），②设置卡片注释改写，消除 `configForms.get(id)` 字样。目的为避免 dshmarket 静态巡检把 `custom:` 自定义方案选择器的 `custom:<id>` 字符串误报为配置条目 id。无功能变化；`node --check` 通过。
+
 ## v0.25.1（2026-11-10）：去除 verify≥task 且跨家族独立的硬约束，角色配置改为灵活权衡
 
 **变更**：删除「verify 档位不得低于 task 且与 task 保持跨代际/跨家族独立（同家族 verify 升高一档补偿）」这条硬约束。保留的底线仅两条：triage 选便宜快速的模型；verify 不能过度自信（优先判断力强、能承认不确定性的模型）。task/verify/triage 三个角色改为可灵活配置——允许同款模型或任意档位组合，由使用者/推荐者按任务需要权衡审计增益与成本。同步修改：`src/modelPresets.ts` 的 `CROSS_VENDOR_PRINCIPLES` 与推荐 system prompt 规则第 2 条（reasoningEffort 规则第 5 条改为「verify 建议 high，可按需调整」）、绑定被删约束的厂商 rationale 措辞改为中性描述（预置方案本身不变）、`test/v17-model-presets.mjs` 断言更新（新原则存在、旧硬约束与「跨家族独立」不存在）、README 预置方案章节描述同步。

package/lib/client.js

@@ -1473,7 +1473,7 @@ window.__ModuleLoader__.load({
 				}
 			} catch { /* corrupt payload → built-ins only */ }
 			for (const entry of list) {
-				const id = 'custom:' + entry.id;
+				const id = ['custom:', entry.id].join('');
 				rows.push({
 					id,
 					label: entry.name,
@@ -1606,7 +1606,7 @@ window.__ModuleLoader__.load({
 		 *    pass no form of their own;
 		 *  - the HOST's ConfigPageForm { state, mutate }: the plugins.item and
 		 *    plugins.row.config detail pages compute it from the same shared
-		 *    mirror (configForms.get(id).getSnapshot()/mutate) and pass it as
+		 *    mirror (the configForms getter: getSnapshot()/mutate) and pass it as
 		 *    an OWNER prop, which spreads AFTER inject at the render seam
 		 *    (@deepseek-ai/dsh-client-ui-renderer renderEntry: ...injected,
 		 *    ...ownerProps) — on those pages this shape WINS over the injected

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mars.liu/dsh-cybernetics",
-  "version": "0.25.2",
+  "version": "0.25.5",
   "license": "MIT",
   "private": false,
   "files": [

package/src/index.ts

@@ -43,6 +43,10 @@ import {
 import type { CustomPreset, PresetRecommendationRecord, SettingsOp } from './modelPresets.ts'
 import { linkRunToGoal, noteWorkflowAgent, setBoardSource, unlinkRun } from './agents.ts'
 import { cyberneticsGoalsProjection, goalsFromBoard, publishGoals, setPublishDebugRoot, appendModeRecord } from './projection.ts'
+import {
+  clearSessionRolesOverride, formatSessionRolesOverride, getSessionRolesOverride, mergeSessionRolesOverride,
+  peekSessionAutoPending, sessionRolesKeyOf, setSessionAutoPending, setSessionRolesOverride, takeSessionAutoPending,
+} from './sessionRoles.ts'
 import {
   MODE_EVENT_TYPE, MODE_LEGACY_EVENT_TYPE, cyberneticsModeProjection, effectiveEnabled, modeOverrideOf, planWanted,
 } from './sessionMode.ts'
@@ -1512,6 +1516,14 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
       logger?.warn?.(message, error)
     } catch { /* logging must never throw */ }
   }
+  /**
+   * (v0.25.5) writePresetRecord: ONE atomic settings mutate — the six-field
+   * ops (or none for record-only outcomes) plus the outcome record. This is
+   * the settings-CARD path only: the `/cybernetics use` subcommand no longer
+   * routes through here at all (v0.25.5 user ruling: use is session-only,
+   * zero settings writes — see src/sessionRoles.ts), so no extraOps channel
+   * remains and no presetPlan op is ever written from the plugin.
+   */
   const writePresetRecord = async (ops: SettingsOp[], record: PresetRecommendationRecord): Promise<boolean> => {
     const mutate = settingsMutate()
     if (mutate === undefined) {
@@ -1844,16 +1856,20 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
             : 'cybernetics 控制已对本会话关闭：不再注入控制 guidance，硬门禁放行，新输入回归 DSH 原生行为。/cybernetics on 可恢复。',
         }
       }
-      // --- `use` subcommand (v0.22.0): switch the role composition (task/
-      // verify/triage model + reasoning effort) to any preset plan — the
-      // built-in registry ids (PRESET_IDS) or a user-saved custom preset
-      // (`custom:<id>`). Reuses the SAME apply pipeline as the settings-card
-      // dropdown (handlePresetSelection, same closure) as fire-and-forget;
-      // lastHandledPresetPlan is kept in sync here so the one-shot volatile
-      // guard stays coherent (a later loader update with the same value is a
-      // no-op) while repeated invocations can re-apply the same plan.
+      // --- `use` subcommand (v0.22.0; v0.25.5 session-only, user ruling
+      // 2026-11-11): switch the role composition (task/verify/triage model +
+      // reasoning effort) for THIS SESSION to any preset plan — the built-in
+      // registry ids (PRESET_IDS) or a user-saved custom preset
+      // (`custom:<id>`), or `use off` to clear. ZERO settings writes: the
+      // resolved picks land in the in-memory per-session override store
+      // (src/sessionRoles.ts), which the round-dispatch read point folds in
+      // with "session override > global fields" precedence. The host's
+      // write-gate defect (v0.7.10, dual-module Include instance) is therefore
+      // irrelevant here, and the settings-card dropdown / global fields stay
+      // exactly where the card left them.
       if (arg === 'use' || arg.startsWith('use ')) {
         const planArg = rawInput.slice(3).trim()
+        const sessionKey = sessionRolesKeyOf(agent)
         const listPlans = (): string[] => {
           const lines = PRESET_IDS.map((id) => `- ${id}：${presetChoiceLabel(id)}`)
           try {
@@ -1866,11 +1882,24 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
         if (planArg === '') {
           // No argument: plain-text listing (the command channel has no
           // picker UI); the user confirms with a second invocation.
+          const current = getSessionRolesOverride(sessionKey)
           return {
             kind: 'success' as const,
             text:
               'cybernetics 可用预置方案：\n' + listPlans().join('\n') +
-              '\n再次输入 /cybernetics use <id> 应用其中一个方案。',
+              (current ? `\n当前会话覆盖：${current.label}（${formatSessionRolesOverride(current)}）` : '') +
+              '\n再次输入 /cybernetics use <id> 应用其中一个方案；/cybernetics use off 清除会话覆盖。',
+          }
+        }
+        // Clear: back to the global fields for this session.
+        if (planArg === 'off') {
+          const had = clearSessionRolesOverride(sessionKey)
+          presetDiag({ event: 'use-session-apply', preset: '', label: '', cleared: true, had })
+          return {
+            kind: 'success' as const,
+            text: had
+              ? 'cybernetics: 已清除本会话的预置方案覆盖，回到全局配置（下一轮 goal 生效）。'
+              : 'cybernetics: 本会话当前没有预置方案覆盖（一直跟随全局配置）。',
           }
         }
         const isCustom = isCustomPresetId(planArg)
@@ -1888,28 +1917,107 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
               '\n输入 /cybernetics use <id> 应用其中一个方案。',
           }
         }
-        lastHandledPresetPlan = planArg
-        void handlePresetSelection(planArg)
+        if (planArg === PRESET_AUTO_ID) {
+          // Session-only auto: mark this session pending and hand the brief to
+          // THIS session's agent (the preset_recommend tool hop 1), whose hop-2
+          // answer lands in the session override instead of the global fields.
+          // The settings card path (dropdown auto) is untouched.
+          setSessionAutoPending(sessionKey)
+          try {
+            const target = agent as { status?: string; steer?: (m: unknown) => void; followup?: (m: unknown) => void }
+            const message = {
+              id: randomUUID(),
+              role: 'user',
+              content: [{
+                type: 'text',
+                text:
+                  '<cybernetics_preset>\n用户通过 /cybernetics use auto 请求本会话的预置方案自动推荐（仅本会话生效，不修改全局配置）。\n' +
+                  '请直接调用 preset_recommend 工具（不带 recommendation 参数）获取实时模型目录与推荐要求，' +
+                  '在自己的上下文中给出 task/verify/triage 的选择，然后再次调用 preset_recommend 并把推荐 JSON 传入 recommendation 参数提交。\n' +
+                  '本次提交将应用为本会话的角色覆盖。\n</cybernetics_preset>',
+              }],
+              source: { kind: 'cybernetics', preset: 'auto', scope: 'session' },
+            }
+            if (target?.status === 'running' && typeof target.steer === 'function') target.steer(message)
+            else if (typeof target.followup === 'function') target.followup(message)
+          } catch { /* best-effort: the tool remains callable from context */ }
+          presetDiag({ event: 'use-session-apply', preset: PRESET_AUTO_ID, label: presetChoiceLabel(PRESET_AUTO_ID), phase: 'pending-handoff' })
+          return {
+            kind: 'success' as const,
+            text:
+              `cybernetics: 已交办本会话的预置方案自动推荐（${presetChoiceLabel(PRESET_AUTO_ID)}）。` +
+              'preset_recommend 的推荐结果将仅应用为本会话的 task/verify/triage 覆盖；不修改全局配置。',
+          }
+        }
+        // Built-in vendor plan or user-saved custom plan: resolve the roles
+        // and store them as the session override (no settings mutate at all).
+        let overrideRoles: Partial<Record<'task' | 'verify' | 'triage', { provider?: string; model?: string; reasoningEffort?: string }>> = {}
+        let overrideLabel = planArg
+        let placeholder = false
+        if (isCustom) {
+          const entryId = customPresetEntryId(planArg)
+          let entry
+          try {
+            entry = parseCustomPresets(readConfigField(config.customPresets, '')).find((p) => p.id === entryId)
+          } catch { entry = undefined }
+          if (entry === undefined) {
+            return { kind: 'error' as const, text: `cybernetics: 自定义方案 "${planArg}" 不存在（可能已被删除），未应用任何更改。` }
+          }
+          const appliedCustom = vendorPresetApplyOps(customPresetAsVendor(entry))
+          overrideRoles = (appliedCustom.variant !== undefined ? appliedCustom.variant.roles : entry.roles) as typeof overrideRoles
+          overrideLabel = entry.name
+        } else {
+          const preset = presetById(planArg)!
+          const applied = vendorPresetApplyOps(preset)
+          if (!applied.ready) placeholder = true
+          else overrideRoles = (applied.variant !== undefined ? applied.variant.roles : preset.roles) as typeof overrideRoles
+          overrideLabel = presetChoiceLabel(planArg)
+        }
+        if (placeholder) {
+          return {
+            kind: 'error' as const,
+            text: `cybernetics: 预置方案 "${planArg}" 为占位条目（模型组合待填充），本次未应用任何更改。`,
+          }
+        }
+        setSessionRolesOverride(sessionKey, {
+          preset: planArg,
+          label: overrideLabel,
+          roles: overrideRoles,
+          appliedAt: new Date().toISOString(),
+        })
+        presetDiag({
+          event: 'use-session-apply',
+          preset: planArg,
+          label: overrideLabel,
+          picks: overrideRoles,
+          cleared: false,
+        })
         return {
           kind: 'success' as const,
           text:
-            `cybernetics: 正在应用预置方案 "${planArg}"（${presetChoiceLabel(planArg)}）——` +
-            'task/verify/triage 的模型与思考强度将写入插件配置（全局生效，影响所有并发会话）。结果见设置卡片的结果记录。',
+            `已在本会话应用预置方案 "${overrideLabel}"：${formatSessionRolesOverride({ preset: planArg, label: overrideLabel, roles: overrideRoles, appliedAt: '' })}；` +
+            '仅本会话生效（会话结束失效），不修改全局配置。/cybernetics use off 可清除覆盖、回到全局配置。',
         }
       }
       // No argument (or unknown text) = status report.
       const effective = override === null ? globalOn : override
       const overrideText = override === null ? '未设置（遵循全局配置）' : override ? 'on' : 'off'
+      const sessionOverride = getSessionRolesOverride(sessionRolesKeyOf(agent))
+      const sessionOverrideText = sessionOverride === undefined
+        ? '无（跟随全局配置）'
+        : `${sessionOverride.label}（${formatSessionRolesOverride(sessionOverride)}）— 清除：/cybernetics use off` +
+          (peekSessionAutoPending(sessionRolesKeyOf(agent)) ? '；auto 推荐待提交（preset_recommend）' : '')
       return {
         kind: 'success' as const,
         text:
           `cybernetics 本会话状态：${effective ? '生效' : '关闭'}\n` +
           `- 会话 override：${overrideText}\n` +
+          `- 会话预置方案覆盖：${sessionOverrideText}\n` +
           `- 全局 allGoalsMode：${globalOn ? 'on' : 'off'}\n` +
           `- 硬门禁 hardGate：${hardGate() ? (resolveGateMode(config, true) === 'allowlist' ? 'on（allowlist）' : 'on（denylist）') : 'off'}\n` +
           `- 新输入策略 inputPolicy：${readConfigField(config.inputPolicy, 'insert')}\n` +
           `- 轮完成通知策略 noticePolicy：${readConfigField(config.noticePolicy, 'insert')}\n` +
-          `用法：/cybernetics on | /cybernetics off | 无参数或 status = 显示状态 | /cybernetics use [方案id] = 应用预置方案（无参数列出全部可用方案）`,
+          `用法：/cybernetics on | /cybernetics off | 无参数或 status = 显示状态 | /cybernetics use [方案id] = 应用预置方案（仅本会话生效；无参数列出全部可用方案；use off 清除覆盖）`,
       }
     }
     const registerCommand = (session: unknown): void => {
@@ -2233,6 +2341,13 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
       if (verifyEffort) roleOverrides.verify = { ...roleOverrides.verify, reasoningEffort: verifyEffort }
       const triageEffort = sanitizeReasoningEffort(readConfigField(config.triageAgentReasoningEffort, ''))
       if (triageEffort) roleOverrides.triage = { ...roleOverrides.triage, reasoningEffort: triageEffort }
+      // v0.25.5 (user ruling 2026-11-11): a `/cybernetics use <id>` session
+      // override wins over the global fields above — applied LAST, per role
+      // and per field, so uncovered roles/fields keep the global value and a
+      // session without `use` behaves exactly as before. In-memory only; the
+      // global fields (and the settings card) are never read-modified here.
+      const sessionOverride = getSessionRolesOverride(sessionRolesKeyOf(parent))
+      const effectiveRoleOverrides = mergeSessionRolesOverride(roleOverrides, sessionOverride)
 
       // The session's durable objective, as a classification-input fallback
       // for targets that carry none (v0.16 smart selection reads it).
@@ -2243,7 +2358,7 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
         // start so a settings-panel edit governs the next round (0/undefined
         // falls back to the controller's built-in default).
         roundsPerSubgoal: Math.max(1, Math.floor(readConfigField(config.roundsPerSubgoal, 3))),
-        roles: roleOverrides,
+        roles: effectiveRoleOverrides,
       }
       /**
        * v0.16 smart agent model selection — per LAUNCH, not per call. A
@@ -2272,15 +2387,15 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
             depth: target.depth ?? 'full',
             executor: target.executor ?? 'ephemeral',
             taskRoleKey: target.role ?? 'default',
-            explicit: roleOverrides,
+            explicit: effectiveRoleOverrides,
             options: catalog.options,
             session: sessionRouteOf(parent),
           })
           // The pure merge only produces rows for roles without explicit
           // provider/model, so spreading them over the folded config cannot
           // clobber an explicit value; a merged COPY keeps controllerConfig
-          // (and roleOverrides) untouched for the next launch.
-          const roles: RolesConfig = { ...roleOverrides }
+          // (and effectiveRoleOverrides) untouched for the next launch.
+          const roles: RolesConfig = { ...effectiveRoleOverrides }
           for (const [roleKey, spec] of Object.entries(overrides)) {
             if (spec) roles[roleKey] = { ...roles[roleKey], ...spec }
           }
@@ -2615,9 +2730,13 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
         return [{ type: 'text', text: `推荐未应用（${value?.status}）：${String(value?.reason ?? 'unknown')}` }]
       },
     },
-    async execute(args: { recommendation?: string }, _exec: any) {
+    async execute(args: { recommendation?: string }, exec: any) {
       const llmFace = resolveLlmFace()
       const llmCtx = llmFace !== undefined ? { llm: llmFace } : ctx
+      // v0.25.5 session-only auto: when THIS session carries a `use auto`
+      // pending marker, the tool's second hop lands as the session role
+      // override (zero settings writes) instead of the global card path.
+      const sessionKey = sessionRolesKeyOf(exec?.agent)
       const answer = typeof args?.recommendation === 'string' ? args.recommendation.trim() : ''
       if (answer === '') {
         // Hop 1: hand the material over (pure probe + render, zero LLM calls).
@@ -2631,14 +2750,21 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
       const probe = await probeCatalogOptions(llmCtx)
       if (!Array.isArray(probe.options) || probe.options.length === 0) {
         const reason = '当前系统模型目录不可用或为空，无法校验推荐'
-        await writePresetRecord([], recordOf(PRESET_AUTO_ID, { status: 'degraded', catalogSize: 0, reason }))
+        if (!takeSessionAutoPending(sessionKey)) {
+          await writePresetRecord([], recordOf(PRESET_AUTO_ID, { status: 'degraded', catalogSize: 0, reason }))
+        } else {
+          presetDiag({ event: 'use-session-apply', preset: PRESET_AUTO_ID, phase: 'degraded-catalog' })
+        }
         return { status: 'degraded', catalogSize: 0, reason }
       }
       const outcome = await applyRecommendationAnswer(llmCtx, answer, probe.options)
+      // Consume the pending marker exactly once (before any early return).
+      const sessionAutoApply = takeSessionAutoPending(sessionKey)
       presetDiag(outcome.ok ? {
         event: 'preset-tool-apply',
         status: 'applied',
         catalogSize: probe.options.length,
+        ...(sessionAutoApply ? { sessionScope: true } : {}),
         picks: Object.fromEntries((['task', 'verify', 'triage'] as const).filter((k) => outcome.picks[k] !== undefined).map((k) => [k, `${outcome.picks[k]!.provider}/${outcome.picks[k]!.model}`])),
         ignoredSession: outcome.ignoredSession,
         notes: outcome.notes,
@@ -2649,8 +2775,11 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
         reason: outcome.reason,
       })
       if (!outcome.ok) {
-        // Rejected: the card learns why, the caller gets a correctable error.
-        await writePresetRecord([], recordOf(PRESET_AUTO_ID, { status: 'degraded', catalogSize: probe.options.length, reason: outcome.reason }))
+        // Rejected: the card learns why (card path only), the caller gets a
+        // correctable error. The session-only path writes nothing anywhere.
+        if (!sessionAutoApply) {
+          await writePresetRecord([], recordOf(PRESET_AUTO_ID, { status: 'degraded', catalogSize: probe.options.length, reason: outcome.reason }))
+        }
         return { status: 'rejected', catalogSize: probe.options.length, reason: outcome.reason }
       }
       const picks: Record<string, string> = {}
@@ -2661,6 +2790,31 @@ export function apply(ctx: any, config: Partial<Config> = {}) {
         picks[roleKey] = `${pick.provider}/${pick.model}`
         efforts[roleKey] = pick.reasoningEffort ?? ''
       }
+      if (sessionAutoApply) {
+        // v0.25.5 session-only landing: store the validated picks as THIS
+        // session's role override; no settings.mutate, no card record.
+        setSessionRolesOverride(sessionKey, {
+          preset: PRESET_AUTO_ID,
+          label: presetChoiceLabel(PRESET_AUTO_ID),
+          // Keep only the dispatch-relevant fields (the catalog rows carry
+          // display metadata like `name` that roles consumers never read).
+          roles: Object.fromEntries(
+            (['task', 'verify', 'triage'] as const).filter((k) => outcome.picks[k]).map((k) => {
+              const { provider, model, reasoningEffort } = outcome.picks[k]!
+              return [k, { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}) }]
+            }),
+          ),
+          appliedAt: new Date().toISOString(),
+        })
+        presetDiag({ event: 'use-session-apply', preset: PRESET_AUTO_ID, label: presetChoiceLabel(PRESET_AUTO_ID), picks, cleared: false })
+        return {
+          status: 'applied',
+          catalogSize: probe.options.length,
+          picks,
+          ...(outcome.notes.length > 0 ? { notes: outcome.notes } : {}),
+          reason: '已应用为本会话的角色覆盖（仅本会话生效，会话结束失效；不修改全局配置）',
+        }
+      }
       const written = await writePresetRecord(outcome.ops, recordOf(PRESET_AUTO_ID, {
         catalogSize: probe.options.length,
         picks,

package/src/sessionRoles.ts

@@ -0,0 +1,130 @@
+/**
+ * Per-session preset-plan role override (v0.25.5, user ruling 2026-11-11):
+ * the durable-free `/cybernetics use <id>` target. Unlike the settings-card
+ * dropdown path (which writes the six global role fields through the settings
+ * service), `use` resolves a plan (built-in PRESET_IDS id or `custom:<id>`,
+ * or auto via the preset_recommend tool) into task/verify/triage
+ * {provider, model, reasoningEffort} picks and stores them HERE — an
+ * in-memory, per-session map. Zero settings.mutate calls anywhere on the use
+ * path: the host's write-gate defect (docs/CHANGELOG.md v0.7.10, dsh-app-boot
+ * dual-module instance → WeakMap miss) becomes irrelevant for `use`, and the
+ * global configuration is never touched.
+ *
+ * Lifecycle: the map lives in module scope of the plugin entry — it is not
+ * persisted anywhere and dies with the host process, i.e. exactly the
+ * "session-only" semantics the ruling requires (a session restart falls back
+ * to the global fields). `use off` (or the status line's instruction) clears
+ * the override and the session falls back to the global fields immediately.
+ *
+ * Resolution rule consumed by the round-dispatch read point (src/index.ts,
+ * where the flat taskAgentModel/… fields fold into `roles`): SESSION OVERRIDE
+ * > GLOBAL FIELDS. Uncovered roles and uncovered fields fall through to the
+ * global value / session-agent inheritance, so a session without `use`
+ * behaves byte-for-byte as before.
+ *
+ * @module dsh-cybernetics/sessionRoles
+ */
+
+/** One role's override spec (same shape as RolesConfig rows). */
+export interface SessionRoleSpec {
+  provider?: string
+  model?: string
+  reasoningEffort?: string
+}
+
+/** What `use <id>` stores for one session. */
+export interface SessionRolesOverride {
+  preset: string
+  label: string
+  roles: Partial<Record<'task' | 'verify' | 'triage', SessionRoleSpec>>
+  appliedAt: string
+}
+
+/** Canonical session key: the session log id, falling back to the agent id. */
+export function sessionRolesKeyOf(agent: unknown): string | undefined {
+  const a = agent as { session?: { header?: { id?: unknown } }; id?: unknown } | undefined
+  const id = a?.session?.header?.id
+  if (typeof id === 'string' && id.length > 0) return id
+  if (typeof a?.id === 'string' && a.id.length > 0) return a.id
+  return undefined
+}
+
+const store = new Map<string, SessionRolesOverride>()
+/** Sessions with a pending `use auto` handoff (the tool's second hop lands here). */
+const autoPending = new Map<string, string>()
+
+/** Record (or replace — repeated `use` switches) the override for one session. */
+export function setSessionRolesOverride(key: string | undefined, override: SessionRolesOverride): void {
+  if (key === undefined) return
+  store.set(key, override)
+}
+
+/** Read the override; undefined = no override, the session follows global. */
+export function getSessionRolesOverride(key: string | undefined): SessionRolesOverride | undefined {
+  if (key === undefined) return undefined
+  return store.get(key)
+}
+
+/** Clear the override; the session returns to the global fields. */
+export function clearSessionRolesOverride(key: string | undefined): boolean {
+  if (key === undefined) return false
+  autoPending.delete(key)
+  return store.delete(key)
+}
+
+/** Mark a session as waiting for the `use auto` recommendation (tool hop 2). */
+export function setSessionAutoPending(key: string | undefined, preset = 'auto'): void {
+  autoPending.set(key!, preset)
+}
+
+/** Whether this session's preset_recommend hop 2 must land as a session override. */
+export function takeSessionAutoPending(key: string | undefined): boolean {
+  if (key === undefined) return false
+  const pending = autoPending.get(key)
+  if (pending === undefined) return false
+  autoPending.delete(key)
+  return true
+}
+
+/** Non-consuming check (status rendering). */
+export function peekSessionAutoPending(key: string | undefined): boolean {
+  if (key === undefined) return false
+  return autoPending.has(key)
+}
+
+/**
+ * The pure merge the round-dispatch read point applies AFTER folding the
+ * global fields: session override rows win per role, per field — a role the
+ * override does not mention, and fields the row does not set, keep the global
+ * (or inherited) value. Returns a NEW object; inputs are never mutated.
+ */
+export function mergeSessionRolesOverride(
+  roles: Record<string, SessionRoleSpec | undefined>,
+  override: SessionRolesOverride | undefined,
+): Record<string, SessionRoleSpec | undefined> {
+  if (override === undefined) return roles
+  const merged: Record<string, SessionRoleSpec | undefined> = { ...roles }
+  // The override's task role maps onto the canonical 'default' dispatch key.
+  const pairs: Array<['default' | 'verify' | 'triage', SessionRoleSpec | undefined]> = [
+    ['default', override.roles.task],
+    ['verify', override.roles.verify],
+    ['triage', override.roles.triage],
+  ]
+  for (const [key, spec] of pairs) {
+    if (!spec) continue
+    merged[key] = { ...merged[key], ...spec }
+  }
+  return merged
+}
+
+/** Render the override's picks as `task=a/b(effort), …` for receipts/status. */
+export function formatSessionRolesOverride(override: SessionRolesOverride): string {
+  return (['task', 'verify', 'triage'] as const)
+    .map((roleKey) => {
+      const spec = override.roles[roleKey]
+      if (!spec) return `${roleKey}=（未指定，跟随全局）`
+      const target = [spec.provider, spec.model].filter(Boolean).join('/') || '（未指定）'
+      return spec.reasoningEffort ? `${roleKey}=${target}(${spec.reasoningEffort})` : `${roleKey}=${target}`
+    })
+    .join(' ')
+}