@@ -670,16 +670,20 @@ When browser is open, you also have access to Chrome DevTools Protocol tools via
         { thinking: 'adaptive (CLI-managed)', effort: this._effortLevel ?? 'default' },
         'Adaptive thinking delegated to CLI for streaming compatibility'
       );
-    } else {
-      // All other models: default to extended thinking at ultra (32768 tokens).
-      // If user explicitly configured a budget, use that; otherwise default to ultra.
+    } else if (this._thinkingMode) {
+      // Non-adaptive models with thinking enabled: use explicit extended thinking.
+      // If user explicitly configured a budget, use that; otherwise default to ultra (32768).
       const budget = this._thinkingBudget > 0 ? this._thinkingBudget : 32768;
       options.thinking = { type: 'enabled', budgetTokens: budget };
       const modeName = budget <= 4096 ? 'think' : budget <= 10240 ? 'hard' : 'ultra';
       logger.info(
         { thinkingMode: modeName, thinkingBudget: budget },
         'Extended thinking ENABLED (fixed budget)'
       );
+    } else {
+      // Non-adaptive models with thinking OFF: omit options.thinking entirely
+      // so the SDK uses its default (no thinking).
+      logger.info('Extended thinking DISABLED for non-adaptive model');
     }
 
     // Permission handling based on session mode
@@ -1692,23 +1696,42 @@ When browser is open, you also have access to Chrome DevTools Protocol tools via
   /**
    * Set effort level for adaptive thinking (Opus 4.6).
    * Maps effort levels to thinking token budgets via setMaxThinkingTokens.
+   *
+   * IMPORTANT: This does NOT mutate the active SDK query. The Claude Code SDK does not
+   * expose runtime setters for effort/thinking on an in-flight query. Changes are stored
+   * internally and take effect when `_createOptions()` is called for the next query.
+   * The frontend sends `effort:set` before each message (chat-actions.ts), so the
+   * timing works out — but mid-turn changes have no effect until the next user message.
    */
   setEffortLevel(effort: 'low' | 'medium' | 'high' | 'max'): void {
     this._effortLevel = effort;
 
-    // Also set budget as fallback for non-adaptive models
+    // Also set budget as fallback for non-adaptive models.
+    // Only update _thinkingMode/_thinkingBudget if thinking is not explicitly disabled.
+    // Without this guard, effort:set unconditionally forces _thinkingMode=true,
+    // which overrides the user's "thinking off" setting for non-adaptive models.
     const budgetMap: Record<string, number> = {
       low: 1024,
       medium: 4096,
       high: 10240,
       max: 32768,
     };
-    this._thinkingMode = true;
-    this._thinkingBudget = budgetMap[effort] ?? 4096;
+    if (this._thinkingMode) {
+      this._thinkingBudget = budgetMap[effort] ?? 4096;
+    }
 
     logger.info({ effort }, 'Effort level set — applies on next query');
   }
 
+  /**
+   * Enable or disable extended thinking for non-adaptive models.
+   *
+   * IMPORTANT: This does NOT mutate the active SDK query. The Claude Code SDK does not
+   * expose runtime setters for thinking on an in-flight query. Changes are stored
+   * internally and take effect when `_createOptions()` is called for the next query.
+   * The frontend sends `thinking:set` before each message (chat-actions.ts), so the
+   * timing works out — but mid-turn changes have no effect until the next user message.
+   */
   setThinkingMode(enabled: boolean, maxTokens?: number): void {
     this._thinkingMode = enabled;
     if (maxTokens !== undefined) {
 
@@ -1934,15 +1934,21 @@ export class SessionManager extends Disposable {
     // Store as thinking preference so session creation picks it up.
     // Without this, the first effort:set is lost (fires before session exists)
     // and the session creates with default budget instead of the user's choice.
+    // NOTE: Only update thinkingEnabled/maxThinkingTokens if thinking is currently
+    // enabled (or was previously enabled in prefs). Without this guard, effort:set
+    // unconditionally forces thinkingEnabled=true, overriding the user's "thinking off"
+    // setting for non-adaptive models like Haiku.
     const budgetMap: Record<string, number> = {
       low: 1024,
       medium: 4096,
       high: 10240,
       max: 32768,
     };
     const prefs = this.modePreferences.get(sessionId) ?? {};
-    prefs.thinkingEnabled = true;
-    prefs.maxThinkingTokens = budgetMap[effort] ?? 4096;
+    if (prefs.thinkingEnabled !== false) {
+      prefs.thinkingEnabled = true;
+      prefs.maxThinkingTokens = budgetMap[effort] ?? 4096;
+    }
     this.modePreferences.set(sessionId, prefs);
   }
 
 
@@ -199,22 +199,27 @@ export function useChatInput(options: UseChatInputOptions): UseChatInputReturn {
     let text = inputText.trim();
     if (!text) return;
 
-    // Prepend skill invocation if a skill chip is attached
-    const skillItems = attachedContext.filter((item) => item.type === 'skill');
-    if (skillItems.length > 0) {
-      const skillPrefix = skillItems.map((s) => `/${s.name}`).join(' ');
-      text = `${skillPrefix} ${text}`;
-    }
-
-    // Prepend @filename tokens for attached files/folders so they persist in JSONL content.
+    // Append @filename tokens for attached files/folders so they persist in JSONL content.
     // The file paths are still sent as attachments for the SDK, but the @tokens ensure
     // the user sees them after switching chats (JSONL content survives, attachedFiles doesn't).
+    // NOTE: File tokens are appended (not prepended) so they don't interfere with
+    // skill prefix `/command` at the start of the message — agent-bridge checks
+    // message.startsWith('/') for slash expansion (agent.ts:1306).
     const fileItems = attachedContext.filter(
       (item) => item.type === 'file' || item.type === 'folder'
     );
     if (fileItems.length > 0) {
-      const filePrefix = fileItems.map((item) => `@${item.name}`).join(' ');
-      text = `${filePrefix} ${text}`;
+      const fileSuffix = fileItems.map((item) => `@${item.name}`).join(' ');
+      text = `${text} ${fileSuffix}`;
+    }
+
+    // Prepend skill invocation if a skill chip is attached.
+    // This must be the LAST prefix operation so `/skillName` stays at position 0,
+    // ensuring agent-bridge's `message.startsWith('/')` check succeeds.
+    const skillItems = attachedContext.filter((item) => item.type === 'skill');
+    if (skillItems.length > 0) {
+      const skillPrefix = skillItems.map((s) => `/${s.name}`).join(' ');
+      text = `${skillPrefix} ${text}`;
     }
 
     // Clear input immediately
 
@@ -288,12 +288,14 @@ export function useChatMessages(): UseChatMessagesReturn {
       session_id: lastCreatedSessionId,
       model: toolState.model,
     });
-    postMessage({
-      type: 'effort:set',
-      uuid: crypto.randomUUID(),
-      session_id: lastCreatedSessionId,
-      effort: toolState.effortLevel,
-    });
+    if (isAdaptiveThinkingModel(toolState.model)) {
+      postMessage({
+        type: 'effort:set',
+        uuid: crypto.randomUUID(),
+        session_id: lastCreatedSessionId,
+        effort: toolState.effortLevel,
+      });
+    }
 
     // Update title
     useUIStore.getState().updateConversationTitle(lastCreatedSessionId, text);
 
@@ -1132,7 +1132,9 @@ fn parse_jsonl_lines(reader: BufReader<fs::File>, path: &Path) -> ParsedJsonl {
                 timestamp,
                 ..
             }) => {
-                if !is_active(&uuid, active_uuids.as_ref()) {
+                let active = is_active(&uuid, active_uuids.as_ref());
+                ctx.last_assistant_active = active;
+                if !active {
                     continue;
                 }
                 ctx.process_assistant_line(uuid, &value, timestamp.as_deref());
@@ -1145,8 +1147,13 @@ fn parse_jsonl_lines(reader: BufReader<fs::File>, path: &Path) -> ParsedJsonl {
                 ..
             }) => {
                 if subtype.as_deref() == Some("turn_duration") {
-                    if let Some(ms) = duration_ms {
-                        ctx.apply_turn_duration(ms);
+                    // Only apply turn_duration if the most recent assistant was on
+                    // the active branch. Dead-branch durations must not overwrite
+                    // the active assistant's value.
+                    if ctx.last_assistant_active {
+                        if let Some(ms) = duration_ms {
+                            ctx.apply_turn_duration(ms);
+                        }
                     }
                 }
             },
@@ -1175,6 +1182,9 @@ struct ParseContext {
     last_timestamp: Option<u64>,
     tool_results: HashMap<String, ToolResultData>,
     last_msg_uuid: Option<String>,
+    /// Tracks whether the most recently encountered assistant line was on the active branch.
+    /// Used to skip `turn_duration` system lines that follow dead-branch assistants.
+    last_assistant_active: bool,
 }
 
 impl ParseContext {
@@ -1188,6 +1198,7 @@ impl ParseContext {
             last_timestamp: None,
             tool_results: HashMap::new(),
             last_msg_uuid: None,
+            last_assistant_active: false,
         }
     }