dsh-ntr 0.3.3 → 0.3.4

package/lib/bridge.js

@@ -12,7 +12,7 @@ import { delimiter, dirname, join } from 'node:path';
 import { Writable, Readable } from 'node:stream';
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { client, methods, ndJsonStream, PROTOCOL_VERSION, RequestError, } from '@agentclientprotocol/sdk';
-import { AcpError, EventHub, PermissionLedger, Transcript, acpToolCallDelta, acpToolCallFromUpdate, buildAdapterModelId, childEnv, isAcpToolContinuation, isUnderPath, mergeCatalogShape, parseCatalogOptions, usableConfigOptions, permissionRequestFrame, pickAutoOption, quoteCommandToken, randomUUID, resolveFsPath, resolveSessionCwd, selectForwardPrompt, isAbsolutePath, acpPresetStatusFromRoster, splitAdapterModelId, updateContentToText, describeUnhandledUpdate, BOOKKEEPING_UPDATES, validateAgentDef, validateTagHalo, validateApprovalDeadlines, validatePermissionTimeoutMode, normalizeApprovalWindow, } from "./impl.js";
+import { AcpError, EventHub, PermissionLedger, Transcript, acpToolCallDelta, acpToolCallFromUpdate, buildAdapterModelId, childEnv, hasUnambiguousModelSelector, isAcpToolContinuation, isUnderPath, mergeCatalogShape, parseCatalogOptions, usableConfigOptions, permissionRequestFrame, pickAutoOption, quoteCommandToken, randomUUID, resolveFsPath, resolveSessionCwd, selectForwardPrompt, isAbsolutePath, acpPresetStatusFromRoster, splitAdapterModelId, updateContentToText, describeUnhandledUpdate, BOOKKEEPING_UPDATES, validateAgentDef, validateTagHalo, validateApprovalDeadlines, validatePermissionTimeoutMode, normalizeApprovalWindow, } from "./impl.js";
 import { DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_TAG_HALO, IDLE_RELEASE_MS } from "./protocol.js";
 import { OUTPUT_CHARS_PER_TOKEN, TurnTpsTracker } from "./tps.js";
 /**
@@ -6287,6 +6287,11 @@ export class BridgeManager {
         const def = this.defsMap.get(agentId);
         if (def === undefined || def.autoDiscoverModels === false || before === undefined)
             return false;
+        // A different model-slot identity is a corrected reading, not newly added
+        // models. Diffing across it would expose an entire real catalog the first
+        // time a parser fix replaces a mislabelled slot (Qoder CN).
+        if (before.model !== undefined && next.model !== undefined && before.model.configId !== next.model.configId)
+            return false;
         const known = new Set((before.model?.choices ?? []).map(choice => choice.value));
         const exposed = new Set(def.exposedModels ?? []);
         const added = (next.model?.choices ?? [])
@@ -6686,6 +6691,12 @@ export class BridgeManager {
         const wanted = modelChoice !== undefined && modelChoice !== '' ? modelChoice : undefined;
         if (wanted === undefined)
             return undefined;
+        // `category` is a UX hint, not identity: an agent may publish several
+        // `category: 'model'` options (Qoder CN ships `reasoning_effort` that way)
+        // and no explicit `model` id. In that case the selector is a guess, so a
+        // "not offered" verdict would refuse a perfectly valid pick — fail open.
+        if (!hasUnambiguousModelSelector(session.configOptions))
+            return undefined;
         const model = parseCatalogOptions(session.configOptions).model;
         if (model === undefined)
             return undefined;
@@ -7630,6 +7641,44 @@ export class BridgeManager {
         });
         return { ok: true, reset: true };
     }
+    /**
+     * 聊天插话的槽位回收：宿主把插话作为同一会话在飞回合的下一步送达，
+     * 拒绝会让整条 host turn 失败。ACP 不能向运行中的 prompt 注入消息，
+     * 所以按插话语义中止当前回合，等 agent 真正结算后再让调用方重发。
+     *
+     * 只处理 `claimTurn` 的 `busy`（agent 仍持有本会话 prompt）；`unsettled`
+     * 说明我们这一侧已经释放过槽位（用户按过停止），保持原样拒绝。
+     *
+     * - 控制器已 settle（响应已到，延后收口还没释放闸门）：什么都不取消，只等闸门；
+     * - agent 真在跑：走用户取消同一条管线（session/cancel + 结算权限 + cancel fallback），
+     *   并立即关闭宿主这一侧的 segment，让闸门在 agent 应答/兜底后打开。
+     */
+    async reclaimChatPrompt(session, controller, signal) {
+        if (session.closed || session.released)
+            return 'ok';
+        if (!controller.hasSettled && session.promptInFlight === true) {
+            await this.bridge(session.agentId).cancel(session);
+            controller.abortActiveSegment();
+        }
+        return this.waitForSettleGate(session, signal);
+    }
+    /** 等 agent 侧 prompt slot 真正释放；步骤被取消时立即返回 aborted。 */
+    waitForSettleGate(session, signal) {
+        const pending = session.settled;
+        if (pending === undefined)
+            return Promise.resolve('ok');
+        if (signal?.aborted)
+            return Promise.resolve('aborted');
+        return new Promise(resolve => {
+            const done = (value) => {
+                signal?.removeEventListener('abort', onAbort);
+                resolve(value);
+            };
+            const onAbort = () => { done('aborted'); };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            void pending.then(() => { done('ok'); });
+        });
+    }
     async *streamPrompt(options) {
         // The plugin's own conversation↔agent mapping decides who serves the turn
         // (see `bindChatAgent`): the driver may arrive here with the previous
@@ -7837,26 +7886,82 @@ export class BridgeManager {
         }
         // One prompt slot per session, and a turn the user aborted still occupies
         // the AGENT's slot until it acknowledges the cancel (see `claimTurn`).
-        const claim = await bridge.claimTurn(session);
+        let claim = await bridge.claimTurn(session);
         if (!claim.ok) {
-            // Never roll the provisional lock back here: a failed claim means ANOTHER
-            // prompt holds the slot (or the agent has not settled it), and that turn
-            // owns the conversation's lock. Closing the session would kill a turn
-            // that is actively streaming — the refusal already tells the user to
-            // retry.
-            yield {
-                type: 'finish',
-                reason: {
-                    kind: 'error',
-                    failure: {
-                        message: claim.reason === 'busy'
-                            ? 'acp: this session already has a prompt in flight'
-                            : 'acp: the agent is still finishing the previous (cancelled) turn; send again in a moment',
-                        code: 'turn_in_flight',
+            // A STEER ("插话"): the host delivers the user's mid-turn message as the
+            // NEXT step of the SAME host turn, so the conversation's own ACP prompt
+            // is still on air. Refusing would fail the whole host turn. ACP forbids
+            // injecting into a running prompt, so the steer's real semantic — abort
+            // the current turn, then send this one — is spelled cancel + wait +
+            // re-claim here.
+            //
+            // Only `busy` can be a steer: it means the AGENT still holds OUR prompt
+            // (`promptInFlight`). `unsettled` means our side already released the
+            // slot (the person pressed stop, or an earlier steer cancelled): the
+            // agent has not acknowledged yet, and quietly queueing the next message
+            // behind a turn the user stopped is not this path's business — that
+            // stays the honest `turn_in_flight` refusal below.
+            //
+            // Only the conversation's OWN in-flight turn qualifies (its live stream
+            // controller, on this very session). A `/acp` RPC turn has no chat
+            // controller, and another conversation never reaches this session, so
+            // both keep the plain refusal: nothing may be cancelled behind a
+            // caller's back.
+            const chatController = claim.reason === 'busy' && options.sessionId !== undefined
+                ? this.turnStreamFor(options.sessionId)
+                : undefined;
+            if (options.sessionId !== undefined
+                && chatController !== undefined
+                && !chatController.stale
+                && chatController.session === session) {
+                const reclaimed = await this.reclaimChatPrompt(session, chatController, options.signal);
+                if (reclaimed === 'aborted') {
+                    // The person pressed stop while the previous turn was winding down:
+                    // the steer is theirs to re-send, nothing goes to the agent.
+                    yield {
+                        type: 'finish',
+                        reason: { kind: 'aborted', failure: { message: 'aborted', code: 'ABORTED' } },
+                    };
+                    return;
+                }
+                // A first turn that produced nothing rolled its provisional lock back
+                // and CLOSED (and forgot) this session: the steer needs a fresh one.
+                if (session.closed || session.released) {
+                    try {
+                        session = await this.getOrCreateDshSession(options.sessionId, agentId);
+                    }
+                    catch (err) {
+                        yield {
+                            type: 'finish',
+                            reason: { kind: 'error', failure: { message: describeError(err), code: 'session_init_failed' } },
+                        };
+                        return;
+                    }
+                }
+                // Same bridge: the session may have been re-created, but the
+                // conversation is still served by this agent's process.
+                claim = await bridge.claimTurn(session);
+            }
+            if (!claim.ok) {
+                // Never roll the provisional lock back here: a failed claim means
+                // ANOTHER prompt holds the slot (or the agent has not settled it), and
+                // that turn owns the conversation's lock. Closing the session would
+                // kill a turn that is actively streaming — the refusal already tells
+                // the user to retry.
+                yield {
+                    type: 'finish',
+                    reason: {
+                        kind: 'error',
+                        failure: {
+                            message: claim.reason === 'busy'
+                                ? 'acp: this session already has a prompt in flight'
+                                : 'acp: the agent is still finishing the previous (cancelled) turn; send again in a moment',
+                            code: 'turn_in_flight',
+                        },
                     },
-                },
-            };
-            return;
+                };
+                return;
+            }
         }
         // Same-agent model/effort switches ride the SAME ACP session (context
         // stays continuous); switching to another agent lands in a separate one

package/lib/impl.js

@@ -834,6 +834,42 @@ export function childEnv(parent, extra) {
     return out;
 }
 // ---- Model catalog (pure parsing of ACP `configOptions`) ----
+/**
+ * ACP categories are free-form UX hints, not identity. Qoder CN tags
+ * `reasoning_effort` as `category: 'model'` (the spec means `thought_level`),
+ * and nothing stops an agent from reusing a category for several options.
+ * Slots are therefore assigned by `configId` first and category second, and a
+ * same-category option NEVER replaces another option's slot: whatever loses
+ * stays reachable through `extras` instead of silently becoming the model list.
+ */
+const EFFORT_OPTION_HINT = /effort|thinking|thought|reason/i;
+function isModelSelector(configId, name) {
+    return configId === 'model' || name.trim().toLowerCase() === 'model';
+}
+function catalogSlotFor(category, configId, name) {
+    const effortish = EFFORT_OPTION_HINT.test(configId) || EFFORT_OPTION_HINT.test(name);
+    if (category === 'model') {
+        // The option explicitly named `model` is the selector even when other
+        // model-scoped options are present.
+        if (isModelSelector(configId, name))
+            return { slot: 'model', rank: 3 };
+        // A model-scoped effort is mislabelled, not a model: route it to the
+        // thought chip when no real `thought_level` option is published.
+        if (effortish)
+            return { slot: 'thought', rank: 1 };
+        // An unknown model-scoped select: a last-resort selector only.
+        return { slot: 'model', rank: 1 };
+    }
+    if (category === 'thought_level')
+        return { slot: 'thought', rank: 3 };
+    if (category === 'mode')
+        return { slot: 'mode', rank: 2 };
+    // `model_config` is where the spec puts model-dependent knobs (effort,
+    // context size); only the effort-shaped ones have a dedicated control.
+    if (category === 'model_config' && effortish)
+        return { slot: 'thought', rank: 1 };
+    return undefined;
+}
 /**
  * Extract select options from a raw ACP `configOptions` payload.
  *
@@ -848,19 +884,13 @@ export function parseCatalogOptions(configOptions) {
     const out = {};
     if (!Array.isArray(configOptions))
         return out;
-    const extras = new Map();
+    const definitions = [];
+    const candidates = [];
     for (const raw of configOptions) {
         if (typeof raw !== 'object' || raw === null)
             continue;
         const row = raw;
         const category = typeof row.category === 'string' ? row.category : undefined;
-        const slot = category === 'model'
-            ? 'model'
-            : category === 'thought_level'
-                ? 'thought'
-                : category === 'mode'
-                    ? 'mode'
-                    : undefined;
         const configIdRaw = row.configId ?? row.id;
         if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number')
             continue;
@@ -869,6 +899,7 @@ export function parseCatalogOptions(configOptions) {
             continue;
         const choices = [];
         collectCatalogChoices(row.options, choices);
+        const name = typeof row.name === 'string' && row.name !== '' ? row.name : configId;
         // A boolean toggle has no `options` at all; its current value is a JSON
         // boolean. It is encoded as 'true' / 'false' so the catalog stays
         // string-typed for every existing reader, and carries `kind` so the
@@ -877,7 +908,7 @@ export function parseCatalogOptions(configOptions) {
             || (typeof row.currentValue === 'boolean' && choices.length === 0);
         const option = {
             configId,
-            name: typeof row.name === 'string' && row.name !== '' ? row.name : configId,
+            name,
             ...(booleanKind ? { kind: 'boolean' } : {}),
             currentValue: booleanKind
                 ? row.currentValue === true || row.currentValue === 'true'
@@ -886,22 +917,81 @@ export function parseCatalogOptions(configOptions) {
                 : typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
             choices,
         };
+        definitions.push(option);
         // A toggle is never a model / thought / mode SELECT: those controls pick
         // among choices. It belongs to the advanced base, where it is a checkbox.
-        if (slot !== undefined && !booleanKind) {
-            out[slot] = option;
+        if (booleanKind)
             continue;
+        const slot = catalogSlotFor(category, configId, name);
+        if (slot !== undefined)
+            candidates.push({ ...slot, option });
+    }
+    const winnerIds = new Set();
+    for (const slot of ['model', 'thought', 'mode']) {
+        let winner;
+        for (const candidate of candidates) {
+            if (candidate.slot !== slot)
+                continue;
+            if (winner === undefined || candidate.rank > winner.rank) {
+                winner = candidate;
+            }
+            else if (candidate.rank === winner.rank && candidate.option.configId === winner.option.configId) {
+                // The same option redefined later in one answer: the last definition
+                // is the current one.
+                winner = candidate;
+            }
         }
-        // Choice-less options have nothing to pick; they would render an empty
-        // section in the advanced menu, so they stay out of the catalog entirely —
-        // except a boolean, whose whole point is that it has no choices.
-        if (choices.length > 0 || booleanKind)
-            extras.set(configId, option);
+        if (winner === undefined)
+            continue;
+        out[slot] = winner.option;
+        winnerIds.add(winner.option.configId);
+    }
+    // Choice-less options have nothing to pick; they would render an empty
+    // section in the advanced menu, so they stay out of the catalog entirely —
+    // except a boolean, whose whole point is that it has no choices. Anything
+    // that lost a slot race is still a real, settable option: keep it here.
+    const extras = new Map();
+    for (const option of definitions) {
+        if (winnerIds.has(option.configId))
+            continue;
+        if (option.choices.length > 0 || option.kind === 'boolean')
+            extras.set(option.configId, option);
     }
     if (extras.size > 0)
         out.extras = [...extras.values()];
     return out;
 }
+/**
+ * Whether a payload names ONE model selector without relying on category
+ * alone. When an agent publishes several `category: 'model'` options and none
+ * is explicitly the `model` id, the category is not trustworthy enough to
+ * reject the user's pick — callers must fail open instead of reporting
+ * `model_unavailable`.
+ */
+export function hasUnambiguousModelSelector(configOptions) {
+    if (!Array.isArray(configOptions))
+        return true;
+    let scoped = 0;
+    let explicit = false;
+    for (const raw of configOptions) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const row = raw;
+        if (row.category !== 'model')
+            continue;
+        const configIdRaw = row.configId ?? row.id;
+        if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number')
+            continue;
+        const configId = String(configIdRaw);
+        if (configId === '')
+            continue;
+        scoped += 1;
+        const name = typeof row.name === 'string' ? row.name : '';
+        if (isModelSelector(configId, name))
+            explicit = true;
+    }
+    return explicit || scoped <= 1;
+}
 /**
  * Fold one per-session option answer's SHAPE into an agent-level catalog.
  *

package/lib/types/bridge.d.ts

@@ -2667,6 +2667,21 @@ export declare class BridgeManager {
      * user is told the context is gone.
      */
     private prepareStalledSession;
+    /**
+     * 聊天插话的槽位回收：宿主把插话作为同一会话在飞回合的下一步送达，
+     * 拒绝会让整条 host turn 失败。ACP 不能向运行中的 prompt 注入消息，
+     * 所以按插话语义中止当前回合，等 agent 真正结算后再让调用方重发。
+     *
+     * 只处理 `claimTurn` 的 `busy`（agent 仍持有本会话 prompt）；`unsettled`
+     * 说明我们这一侧已经释放过槽位（用户按过停止），保持原样拒绝。
+     *
+     * - 控制器已 settle（响应已到，延后收口还没释放闸门）：什么都不取消，只等闸门；
+     * - agent 真在跑：走用户取消同一条管线（session/cancel + 结算权限 + cancel fallback），
+     *   并立即关闭宿主这一侧的 segment，让闸门在 agent 应答/兜底后打开。
+     */
+    private reclaimChatPrompt;
+    /** 等 agent 侧 prompt slot 真正释放；步骤被取消时立即返回 aborted。 */
+    private waitForSettleGate;
     streamPrompt(options: GenerateOptions): AsyncIterable<StreamChunk>;
 }
 export declare class AcpLlmAdapter implements LlmAdapterLike {

package/lib/types/impl.d.ts

@@ -248,6 +248,14 @@ export declare function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string
  * anything unusable is skipped silently.
  */
 export declare function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog;
+/**
+ * Whether a payload names ONE model selector without relying on category
+ * alone. When an agent publishes several `category: 'model'` options and none
+ * is explicitly the `model` id, the category is not trustworthy enough to
+ * reject the user's pick — callers must fail open instead of reporting
+ * `model_unavailable`.
+ */
+export declare function hasUnambiguousModelSelector(configOptions: unknown): boolean;
 /**
  * Fold one per-session option answer's SHAPE into an agent-level catalog.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ntr",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Interactive Agent Client Protocol (ACP) client for the DSH web UI: attach any ACP-capable agent and stream its session.",
   "repository": "https://github.com/GDWhisper/dsh-ntr.git",
   "type": "module",

package/src/bridge.ts

@@ -40,6 +40,7 @@ import {
   acpToolCallFromUpdate,
   buildAdapterModelId,
   childEnv,
+  hasUnambiguousModelSelector,
   isAcpToolContinuation,
   isUnderPath,
   mergeCatalogShape,
@@ -6970,6 +6971,10 @@ export class BridgeManager {
   private autoExposeNewModels(agentId: string, next: AcpAgentCatalog, before: AcpAgentCatalog | undefined): boolean {
     const def = this.defsMap.get(agentId)
     if (def === undefined || def.autoDiscoverModels === false || before === undefined) return false
+    // A different model-slot identity is a corrected reading, not newly added
+    // models. Diffing across it would expose an entire real catalog the first
+    // time a parser fix replaces a mislabelled slot (Qoder CN).
+    if (before.model !== undefined && next.model !== undefined && before.model.configId !== next.model.configId) return false
     const known = new Set((before.model?.choices ?? []).map(choice => choice.value))
     const exposed = new Set(def.exposedModels ?? [])
     const added = (next.model?.choices ?? [])
@@ -7360,6 +7365,11 @@ export class BridgeManager {
   private staleModelChoice(session: LiveSession, modelChoice: string | undefined): string | undefined {
     const wanted = modelChoice !== undefined && modelChoice !== '' ? modelChoice : undefined
     if (wanted === undefined) return undefined
+    // `category` is a UX hint, not identity: an agent may publish several
+    // `category: 'model'` options (Qoder CN ships `reasoning_effort` that way)
+    // and no explicit `model` id. In that case the selector is a guess, so a
+    // "not offered" verdict would refuse a perfectly valid pick — fail open.
+    if (!hasUnambiguousModelSelector(session.configOptions)) return undefined
     const model = parseCatalogOptions(session.configOptions).model
     if (model === undefined) return undefined
     if (model.currentValue === wanted) return undefined
@@ -8309,6 +8319,47 @@ export class BridgeManager {
     return { ok: true, reset: true }
   }
 
+  /**
+   * 聊天插话的槽位回收：宿主把插话作为同一会话在飞回合的下一步送达，
+   * 拒绝会让整条 host turn 失败。ACP 不能向运行中的 prompt 注入消息，
+   * 所以按插话语义中止当前回合，等 agent 真正结算后再让调用方重发。
+   *
+   * 只处理 `claimTurn` 的 `busy`（agent 仍持有本会话 prompt）；`unsettled`
+   * 说明我们这一侧已经释放过槽位（用户按过停止），保持原样拒绝。
+   *
+   * - 控制器已 settle（响应已到，延后收口还没释放闸门）：什么都不取消，只等闸门；
+   * - agent 真在跑：走用户取消同一条管线（session/cancel + 结算权限 + cancel fallback），
+   *   并立即关闭宿主这一侧的 segment，让闸门在 agent 应答/兜底后打开。
+   */
+  private async reclaimChatPrompt(
+    session: LiveSession,
+    controller: TurnStreamController,
+    signal?: AbortSignal,
+  ): Promise<'ok' | 'aborted'> {
+    if (session.closed || session.released) return 'ok'
+    if (!controller.hasSettled && session.promptInFlight === true) {
+      await this.bridge(session.agentId).cancel(session)
+      controller.abortActiveSegment()
+    }
+    return this.waitForSettleGate(session, signal)
+  }
+
+  /** 等 agent 侧 prompt slot 真正释放；步骤被取消时立即返回 aborted。 */
+  private waitForSettleGate(session: LiveSession, signal?: AbortSignal): Promise<'ok' | 'aborted'> {
+    const pending = session.settled
+    if (pending === undefined) return Promise.resolve('ok')
+    if (signal?.aborted) return Promise.resolve('aborted')
+    return new Promise(resolve => {
+      const done = (value: 'ok' | 'aborted'): void => {
+        signal?.removeEventListener('abort', onAbort)
+        resolve(value)
+      }
+      const onAbort = (): void => { done('aborted') }
+      signal?.addEventListener('abort', onAbort, { once: true })
+      void pending.then(() => { done('ok') })
+    })
+  }
+
   async *streamPrompt(options: GenerateOptions): AsyncIterable<StreamChunk> {
     // The plugin's own conversation↔agent mapping decides who serves the turn
     // (see `bindChatAgent`): the driver may arrive here with the previous
@@ -8514,26 +8565,81 @@ export class BridgeManager {
 
     // One prompt slot per session, and a turn the user aborted still occupies
     // the AGENT's slot until it acknowledges the cancel (see `claimTurn`).
-    const claim = await bridge.claimTurn(session)
+    let claim = await bridge.claimTurn(session)
     if (!claim.ok) {
-      // Never roll the provisional lock back here: a failed claim means ANOTHER
-      // prompt holds the slot (or the agent has not settled it), and that turn
-      // owns the conversation's lock. Closing the session would kill a turn
-      // that is actively streaming — the refusal already tells the user to
-      // retry.
-      yield {
-        type: 'finish',
-        reason: {
-          kind: 'error',
-          failure: {
-            message: claim.reason === 'busy'
-              ? 'acp: this session already has a prompt in flight'
-              : 'acp: the agent is still finishing the previous (cancelled) turn; send again in a moment',
-            code: 'turn_in_flight',
+      // A STEER ("插话"): the host delivers the user's mid-turn message as the
+      // NEXT step of the SAME host turn, so the conversation's own ACP prompt
+      // is still on air. Refusing would fail the whole host turn. ACP forbids
+      // injecting into a running prompt, so the steer's real semantic — abort
+      // the current turn, then send this one — is spelled cancel + wait +
+      // re-claim here.
+      //
+      // Only `busy` can be a steer: it means the AGENT still holds OUR prompt
+      // (`promptInFlight`). `unsettled` means our side already released the
+      // slot (the person pressed stop, or an earlier steer cancelled): the
+      // agent has not acknowledged yet, and quietly queueing the next message
+      // behind a turn the user stopped is not this path's business — that
+      // stays the honest `turn_in_flight` refusal below.
+      //
+      // Only the conversation's OWN in-flight turn qualifies (its live stream
+      // controller, on this very session). A `/acp` RPC turn has no chat
+      // controller, and another conversation never reaches this session, so
+      // both keep the plain refusal: nothing may be cancelled behind a
+      // caller's back.
+      const chatController = claim.reason === 'busy' && options.sessionId !== undefined
+        ? this.turnStreamFor(options.sessionId)
+        : undefined
+      if (options.sessionId !== undefined
+        && chatController !== undefined
+        && !chatController.stale
+        && chatController.session === session) {
+        const reclaimed = await this.reclaimChatPrompt(session, chatController, options.signal)
+        if (reclaimed === 'aborted') {
+          // The person pressed stop while the previous turn was winding down:
+          // the steer is theirs to re-send, nothing goes to the agent.
+          yield {
+            type: 'finish',
+            reason: { kind: 'aborted', failure: { message: 'aborted', code: 'ABORTED' } },
+          }
+          return
+        }
+        // A first turn that produced nothing rolled its provisional lock back
+        // and CLOSED (and forgot) this session: the steer needs a fresh one.
+        if (session.closed || session.released) {
+          try {
+            session = await this.getOrCreateDshSession(options.sessionId, agentId)
+          } catch (err) {
+            yield {
+              type: 'finish',
+              reason: { kind: 'error', failure: { message: describeError(err), code: 'session_init_failed' } },
+            }
+            return
+          }
+        }
+        // Same bridge: the session may have been re-created, but the
+        // conversation is still served by this agent's process.
+        claim = await bridge.claimTurn(session)
+      }
+      if (!claim.ok) {
+        // Never roll the provisional lock back here: a failed claim means
+        // ANOTHER prompt holds the slot (or the agent has not settled it), and
+        // that turn owns the conversation's lock. Closing the session would
+        // kill a turn that is actively streaming — the refusal already tells
+        // the user to retry.
+        yield {
+          type: 'finish',
+          reason: {
+            kind: 'error',
+            failure: {
+              message: claim.reason === 'busy'
+                ? 'acp: this session already has a prompt in flight'
+                : 'acp: the agent is still finishing the previous (cancelled) turn; send again in a moment',
+              code: 'turn_in_flight',
+            },
           },
-        },
+        }
+        return
       }
-      return
     }
 
     // Same-agent model/effort switches ride the SAME ACP session (context

package/src/impl.ts

@@ -867,6 +867,48 @@ export function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string, string
 
 // ---- Model catalog (pure parsing of ACP `configOptions`) ----
 
+/**
+ * ACP categories are free-form UX hints, not identity. Qoder CN tags
+ * `reasoning_effort` as `category: 'model'` (the spec means `thought_level`),
+ * and nothing stops an agent from reusing a category for several options.
+ * Slots are therefore assigned by `configId` first and category second, and a
+ * same-category option NEVER replaces another option's slot: whatever loses
+ * stays reachable through `extras` instead of silently becoming the model list.
+ */
+const EFFORT_OPTION_HINT = /effort|thinking|thought|reason/i
+
+function isModelSelector(configId: string, name: string): boolean {
+  return configId === 'model' || name.trim().toLowerCase() === 'model'
+}
+
+type CatalogSlot = 'model' | 'thought' | 'mode'
+
+interface CatalogSlotCandidate {
+  slot: CatalogSlot
+  rank: number
+  option: AcpCatalogOption
+}
+
+function catalogSlotFor(category: string | undefined, configId: string, name: string): Omit<CatalogSlotCandidate, 'option'> | undefined {
+  const effortish = EFFORT_OPTION_HINT.test(configId) || EFFORT_OPTION_HINT.test(name)
+  if (category === 'model') {
+    // The option explicitly named `model` is the selector even when other
+    // model-scoped options are present.
+    if (isModelSelector(configId, name)) return { slot: 'model', rank: 3 }
+    // A model-scoped effort is mislabelled, not a model: route it to the
+    // thought chip when no real `thought_level` option is published.
+    if (effortish) return { slot: 'thought', rank: 1 }
+    // An unknown model-scoped select: a last-resort selector only.
+    return { slot: 'model', rank: 1 }
+  }
+  if (category === 'thought_level') return { slot: 'thought', rank: 3 }
+  if (category === 'mode') return { slot: 'mode', rank: 2 }
+  // `model_config` is where the spec puts model-dependent knobs (effort,
+  // context size); only the effort-shaped ones have a dedicated control.
+  if (category === 'model_config' && effortish) return { slot: 'thought', rank: 1 }
+  return undefined
+}
+
 /**
  * Extract select options from a raw ACP `configOptions` payload.
  *
@@ -880,24 +922,19 @@ export function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string, string
 export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
   const out: AcpAgentCatalog = {}
   if (!Array.isArray(configOptions)) return out
-  const extras = new Map<string, AcpCatalogOption>()
+  const definitions: AcpCatalogOption[] = []
+  const candidates: CatalogSlotCandidate[] = []
   for (const raw of configOptions) {
     if (typeof raw !== 'object' || raw === null) continue
     const row = raw as Record<string, unknown>
     const category = typeof row.category === 'string' ? row.category : undefined
-    const slot = category === 'model'
-      ? 'model'
-      : category === 'thought_level'
-        ? 'thought'
-        : category === 'mode'
-          ? 'mode'
-          : undefined
     const configIdRaw = row.configId ?? row.id
     if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number') continue
     const configId = String(configIdRaw)
     if (configId === '') continue
     const choices: NonNullable<AcpAgentCatalog['model']>['choices'] = []
     collectCatalogChoices(row.options, choices)
+    const name = typeof row.name === 'string' && row.name !== '' ? row.name : configId
     // A boolean toggle has no `options` at all; its current value is a JSON
     // boolean. It is encoded as 'true' / 'false' so the catalog stays
     // string-typed for every existing reader, and carries `kind` so the
@@ -906,7 +943,7 @@ export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
       || (typeof row.currentValue === 'boolean' && choices.length === 0)
     const option: AcpCatalogOption = {
       configId,
-      name: typeof row.name === 'string' && row.name !== '' ? row.name : configId,
+      name,
       ...(booleanKind ? { kind: 'boolean' as const } : {}),
       currentValue: booleanKind
         ? row.currentValue === true || row.currentValue === 'true'
@@ -915,21 +952,69 @@ export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
         : typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
       choices,
     }
+    definitions.push(option)
     // A toggle is never a model / thought / mode SELECT: those controls pick
     // among choices. It belongs to the advanced base, where it is a checkbox.
-    if (slot !== undefined && !booleanKind) {
-      out[slot] = option
-      continue
-    }
-    // Choice-less options have nothing to pick; they would render an empty
-    // section in the advanced menu, so they stay out of the catalog entirely —
-    // except a boolean, whose whole point is that it has no choices.
-    if (choices.length > 0 || booleanKind) extras.set(configId, option)
+    if (booleanKind) continue
+    const slot = catalogSlotFor(category, configId, name)
+    if (slot !== undefined) candidates.push({ ...slot, option })
+  }
+  const winnerIds = new Set<string>()
+  for (const slot of ['model', 'thought', 'mode'] as const) {
+    let winner: CatalogSlotCandidate | undefined
+    for (const candidate of candidates) {
+      if (candidate.slot !== slot) continue
+      if (winner === undefined || candidate.rank > winner.rank) {
+        winner = candidate
+      } else if (candidate.rank === winner.rank && candidate.option.configId === winner.option.configId) {
+        // The same option redefined later in one answer: the last definition
+        // is the current one.
+        winner = candidate
+      }
+    }
+    if (winner === undefined) continue
+    out[slot] = winner.option
+    winnerIds.add(winner.option.configId)
+  }
+  // Choice-less options have nothing to pick; they would render an empty
+  // section in the advanced menu, so they stay out of the catalog entirely —
+  // except a boolean, whose whole point is that it has no choices. Anything
+  // that lost a slot race is still a real, settable option: keep it here.
+  const extras = new Map<string, AcpCatalogOption>()
+  for (const option of definitions) {
+    if (winnerIds.has(option.configId)) continue
+    if (option.choices.length > 0 || option.kind === 'boolean') extras.set(option.configId, option)
   }
   if (extras.size > 0) out.extras = [...extras.values()]
   return out
 }
 
+/**
+ * Whether a payload names ONE model selector without relying on category
+ * alone. When an agent publishes several `category: 'model'` options and none
+ * is explicitly the `model` id, the category is not trustworthy enough to
+ * reject the user's pick — callers must fail open instead of reporting
+ * `model_unavailable`.
+ */
+export function hasUnambiguousModelSelector(configOptions: unknown): boolean {
+  if (!Array.isArray(configOptions)) return true
+  let scoped = 0
+  let explicit = false
+  for (const raw of configOptions) {
+    if (typeof raw !== 'object' || raw === null) continue
+    const row = raw as Record<string, unknown>
+    if (row.category !== 'model') continue
+    const configIdRaw = row.configId ?? row.id
+    if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number') continue
+    const configId = String(configIdRaw)
+    if (configId === '') continue
+    scoped += 1
+    const name = typeof row.name === 'string' ? row.name : ''
+    if (isModelSelector(configId, name)) explicit = true
+  }
+  return explicit || scoped <= 1
+}
+
 /**
  * Fold one per-session option answer's SHAPE into an agent-level catalog.
  *