pi-advisor-flow 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project are documented here.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.5.1
+
+### Changed
+
+- Updated CI and local validation to Bun 1.4.1 and kept the Pi compatibility packages at 0.84.4; Pi 0.85.0 currently adds an eager `/server` import without declaring the `@earendil-works/pi-server` dependency required by its coding-agent entry point.
+- Kept benchmark tests out of the normal test run; use `bun run test:bench` to run them explicitly.
+- Added Socket security dependency overrides and a `socket` script for `bunx socket optimize`.
+
+### Added
+
+- Added a repository-only failsafe benchmark with an offline replay tier, a
+  24-item decision-point corpus, a fail-closed Pi/Harbor ReactBench adapter,
+  pinned live-tier controls, hard budget limits, and task-level
+  uplift/dominance reporting. See [Benchmarking](docs/benchmark.md).
+- Added bounded local Harbor runtime controls for Apple Container experiments,
+  Docker build-cache cleanup, and a recorded one-hour agent timeout for complex
+  ReactBench tasks.
+- Added a disposable, credential-free GitHub build compatibility layer for
+  pinned ReactBench Dockerfiles whose Git 2.39 transport is rejected by the
+  GitHub endpoint, with bounded pre-agent Harbor infrastructure retries and
+  per-attempt artifacts for transient build and transport failures.
+- Derived the host Harbor command timeout from the bounded agent timeout and
+  made timeout cleanup terminate the full Harbor process group, including the
+  broker and descendants.
+- Ensured configured Advisor reasoning effort reaches the provider-facing
+  request field used by current Pi AI adapters.
+
+### Fixed
+
+- Made `/advisor` open the available-model picker on first use or when either saved model is missing or unavailable; activation never silently selects a model outside the user's available catalog.
+- Added a concise `/advisor` explanation of the Advisor's second-opinion role.
+- Preserved Markdown formatting in visible Scout and nested Advisor thinking previews while retaining their speech-bubble cue. During streaming, incomplete Markdown delimiters display transiently until they close, which is expected behavior when thinking arrives incrementally.
+- Adopted an explicit `/model` selection made before `/advisor` as the Executor on the next successful activation, without persisting ordinary model changes while the flow is off.
+
+## [5.1.0] - 2026-09-04 [YANKED]
+
+### Release status
+
+- Published by mistake instead of `0.5.1`; withdrawn from npm and removed from Git, with `latest` restored to `0.5.0`.
+
 ## 0.5.0
 
 ### Changed

package/README.md

@@ -1,4 +1,4 @@
-# pi-advisor
+# [pi-advisor](https://github.com/philipbrembeck/pi-advisor)
 
 <div align="center">
 
@@ -8,114 +8,79 @@ A configurable second-opinion workflow for <a href="https://github.com/earendil-
 
 </div>
 
-
 ![d18m Downloads](https://img.shields.io/npm/d18m/pi-advisor-flow?style=flat) ![NPM Version](https://img.shields.io/npm/v/pi-advisor-flow?style=flat)
 
 `pi-advisor-flow` keeps one model focused on execution and makes a second, smarter model available for consequential decisions, stalled work, and final reviews. The Executor still owns the work. The Advisor challenges assumptions, exposes risks, and suggests verification steps without taking over or running tools.
 
-The idea is simple: keep implementation on a fast model and borrow frontier reasoning only when decisions matter. [Read why this workflow is useful](https://philipbrembeck.com/writings/2026/07/only-as-much-intelligence-as-you-need).
+Keep implementation on a fast model and borrow frontier reasoning only when decisions matter. [Read why this workflow is useful](https://philipbrembeck.com/writings/2026/07/only-as-much-intelligence-as-you-need).
+
+## How it works
 
-## Features
+1. The Executor works on your task as usual.
+2. It calls `ask_advisor`, or an enabled gate starts a review.
+3. pi-advisor reconstructs the relevant conversation and allowed repository context.
+4. The Advisor returns an opinion. The Executor decides what to adopt, changes the code, and validates it.
 
-- **On-demand second opinions** through the `ask_advisor` tool or `/advisor-manual`.
-- **Configurable review gates** before plans, after repeated failures, and before declaring completion.
-- **Automatic loop detection** for repeated tool calls, with explicit proceed, revise, or blocked decisions.
-- **Separate model and reasoning controls** for the Executor and Advisor.
-- **Advisor usage accounting** with per-response token/cost details and optional cumulative direct usage in the Pi footer and session summary. Per-response usage and cost details are shown by default and can be hidden independently from the footer in `/advisor-settings`.
-- **Privacy controls** for conversation history, repository context, explicit tracked/untracked file handoff, tool results, secret redaction, and outcome logging.
-- **Optional persistent activation, Simple mode, session summaries, and Herdr integration.**
-- **Compact searchable `/advisor-settings` controls** that match Pi's settings list and save changes immediately.
-- **EXPERIMENTAL Advisor Scout** that uses the configured Executor model to curate conversation evidence before every Advisor call.
+Regular consultations do not block execution. Automatic loop gates are different: they can stop a repeated tool action or session based on your configured failure policy.
 
 ## Install
 
-Requires Pi 0.84.1 or later and is compatible with Herdr 0.8.0.
+Requires Pi 0.84.1 or later.
 
 ```bash
-# npm
 pi install npm:pi-advisor-flow
+```
 
-# GitHub
-pi install git:github.com/philipbrembeck/pi-advisor.git
+You can also install from GitHub:
 
-# local checkout
-pi install /path/to/pi-advisor
+```bash
+pi install git:github.com/philipbrembeck/pi-advisor.git
 ```
 
-Restart or reload Pi after installation.
+Reload Pi after installing.
 
 ## Quick start
 
-1. Run `/advisor` to enable the flow and register `ask_advisor`.
-2. Run `/advisor-models` to choose the Executor and Advisor models. Current model and thinking-level selections appear first and ticked, so pressing Enter keeps them.
-3. Run `/advisor-settings` to configure review gates, context, privacy, and limits. Type to fuzzy-search settings; changes save immediately.
-
-![Advisor Settings](https://raw.githubusercontent.com/philipbrembeck/pi-advisor/refs/heads/main/assets/settings.png)
-
-Unknown fields in `advisor.json` are preserved for forward compatibility and reported as non-blocking warnings. Invalid recognized values remain errors, and Advisor commands show the configuration problem without crashing their handlers.
-
-You can also enable the flow and select both models at once:
-
 ```text
-/advisor executor=openai-codex/gpt-5.6-luna advisor=openai-codex/gpt-5.6-sol
+/advisor            # Enable the Advisor Flow
+/advisor-models     # Choose the Executor and Advisor models
+/advisor-settings   # Configure behavior, modes, etc.
 ```
 
-## How it works
-
-1. The Executor investigates the task and forms its own candidate direction.
-2. For a consequential decision, stalled attempt, or final review, it calls `ask_advisor` with the reconstructed conversation and allowed repository context.
-3. When Experimental Advisor Scout is enabled, the configured Executor model selects relevant conversation groups and writes a short, explicitly untrusted synthesis.
-4. The Advisor receives selected verbatim evidence, required current-request context, and the unchanged deterministic repository, preference, draft, and attachment regions.
-5. The Executor decides what to adopt, performs the work, and validates the result.
+On first use, or whenever a saved model is unavailable, `/advisor` opens the same available-model picker as `/advisor-models`; it never silently chooses an unconfigured model. After activation, `/advisor` explains that the Advisor reviews the Executor's context without changing files or running tools.
 
-A normal consultation never blocks execution. The optional automatic loop gate is different: it evaluates repeated tool calls and applies the configured failure policy when the Advisor says to revise, reports a block, is unavailable, or returns an invalid decision.
+From the Executor, `ask_advisor({})` requests a general review. A targeted `question` or concise `draft` can focus the review on a particular decision.
 
-Advisor responses show provider-reported input, output, cache, and cost details when available. Successful `ask_advisor` tool results also carry normalized usage into Pi's built-in `Tools/summaries` and `/cost` totals. Manual consultations and automatic gates remain in the separate session-local direct Advisor accounting because they are custom messages, so they are not double-counted in Pi's Executor totals. Missing or partial provider usage is shown as unavailable rather than fabricated as zero usage. `/advisor-settings` independently controls per-response usage details and the cumulative Advisor footer without disabling this accounting; the footer is off by default.
-
-Successful calls return an opaque `adviceId`. If global outcome logging is enabled, the Executor can call `record_advisor_outcome` once to record whether the advice was adopted and whether final validation passed.
-
-### Experimental Advisor Scout
-
-Experimental Advisor Scout is off by default. Enable `Experimental Advisor Scout` in the advanced `/advisor-settings` screen or set `"advisorScoutEnabled": true` in the global `advisor.json`.
-
-Scout runs before `ask_advisor`, `/advisor-manual`, and automatic Advisor gates. It uses the configured Executor model and Executor reasoning effort in a separate model call. This adds cost and latency, but can reduce cost in the Advisor call. The compact result shows the model, selection counts, elapsed time, and usage/cost details; `Ctrl+O` shows bounded selected labels and the synthesis. Usage and cost details can be hidden in `/advisor-settings`.
-
-Scout receives a bounded manifest of conversation and tool-history groups after the normal tool disclosure, result-cap, and redaction policies are applied. The Scout manifest has its own fixed transport limit, while the reconstructed conversation remains bounded by the Advisor's remaining context budget after repository context; manifest metadata no longer consumes that Advisor conversation budget. A zero remaining budget produces no history groups. For a pending `ask_advisor` call, Scout receives only the allowlisted question and Git-context preference, never the draft or explicit attachment paths. Scout does not receive the deterministic Git context, draft, project preferences, or explicit tracked and untracked attachments. Those regions are appended later through their existing consent and cap rules.
-
-This experiment adapts the context-boundary idea from Zhang et al., ["FastContext: Training Efficient Repository Explorer for Coding Agents"](https://arxiv.org/html/2606.14066v1). It is not a reproduction of FastContext. pi-advisor Scout curates conversation history only.
+In the Settings, enable the Simple Mode for a quick start.
+![Pi Advisor Settings Panel](https://raw.githubusercontent.com/philipbrembeck/pi-advisor/refs/heads/main/assets/settings.png)
 
 ## Commands
 
-| Command | Purpose |
-| --- | --- |
-| `/advisor` | Enable the flow and optionally override the Executor, Advisor, or context limit. |
-| `/advisor-manual [focus]` | Open a TUI form for a parallel consultation, or consult immediately in non-TUI modes; shows progress in the footer. |
-| `/advisor-models` | Choose both models and their reasoning effort; current models are preselected. |
-| `/advisor-settings` | Configure behavior, context, gates, privacy, and output limits. |
-| `/advisor-off` | Disable the flow and turn off persistent activation. |
+| Command                   | What it does                                      |
+| ------------------------- | ------------------------------------------------- |
+| `/advisor`                | Enable the flow; choose available models when needed. |
+| `/advisor-manual [focus]` | Ask for an immediate second opinion.              |
+| `/advisor-models`         | Choose the Executor and Advisor models.           |
+| `/advisor-settings`       | Configure behavior, context, privacy, and limits. |
+| `/advisor-off`            | Disable the flow and persistent activation.       |
 
-In the interactive TUI, `/advisor-manual [focus]` opens a centered overlay. The optional focus text is prefilled and editable; Enter submits, Shift+Enter inserts a newline, Tab/Shift+Tab moves focus, and Escape cancels. The form lets you choose the permitted Git context level, with choices above the configured ceiling hidden. `None` withholds Git data only; it does not remove configured conversation history. After submission, the call, Scout, and Advisor streaming progress appear immediately in the transcript. Canceling has no consultation side effects. RPC, print, and JSON invocations retain their immediate argument-driven behavior.
-
-The Executor calls `ask_advisor({})` for a general review. It can pass a targeted `question` or a concise `draft` describing proposed work, validation, and remaining risks. If the Advisor explicitly says it cannot review a specifically named file, the Executor may make a sequential follow-up call with `includeTrackedFiles` when global consent is enabled and the file is relevant. Draft claims give the Advisor review context; they are not verification evidence.
+### Experimental Advisor Scout
 
-## What gets sent to the Advisor
+Advisor Scout is off by default. When enabled, the Executor model first selects relevant conversation history before the Advisor sees it. This adds a model call, latency, and cost. See the [configuration guide](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/configuration.md) for details.
 
-Advisor context can include user messages, tool calls, tool results, and repository information. Secret redaction is off by default, and tools without an explicit disclosure policy default to full context. Review the privacy settings before using the extension with sensitive work.
+## Privacy
 
-When Experimental Advisor Scout is enabled, the Executor model provider also receives bounded Advisor-eligible conversation history. Scout does not receive the deterministic repository, draft, preference, or explicit-file regions described below.
+Advisor requests can include user messages, tool calls, tool results, and repository information. `/advisor-settings` controls context, tool disclosure, redaction, and explicit file handoff. Secret redaction is off by default, and tools without an explicit policy use full context. Settings are global, so a project cannot silently change them.
 
-Repository context is configurable from no access through changed-file summaries to a capped patch. When context is disabled or its budget is zero, the Advisor is told it was withheld rather than shown an apparently clean tree. Explicit tracked and untracked file contents require separate global opt-ins; attachments are capped, redacted when configured, and sent as untrusted data.
+Read [Privacy and data handling](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/privacy.md) before using pi-advisor with sensitive work.
 
 ## Documentation
 
 - [Configuration and automatic loop gates](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/configuration.md)
 - [Privacy and data handling](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/privacy.md)
 - [Development](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/development.md)
-- [Documentation index](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/README.md)
-
-## Links
-
-- [MIT License](LICENSE)
+- [Benchmarking](docs/benchmark.md)
 - [Changelog](CHANGELOG.md)
+- [MIT License](LICENSE)
 - [npm package](https://www.npmjs.com/package/pi-advisor-flow)
 - [Why use an Advisor flow?](https://philipbrembeck.com/writings/2026/07/only-as-much-intelligence-as-you-need)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "pi-package",
@@ -28,33 +28,45 @@
     "README.md"
   ],
   "scripts": {
+    "bench:decisions": "bun bench/src/cli.ts decisions",
+    "bench:evaluate": "bun bench/src/cli.ts evaluate",
+    "bench:replay": "bun bench/src/cli.ts replay",
+    "bench:screen": "bun bench/src/cli.ts screen",
     "format": "bunx ultracite fix --linter-enabled=false",
     "lint": "bunx ultracite check",
     "lint:fix": "bunx ultracite fix",
     "package:check": "node scripts/check-package.mjs",
     "prepare": "husky",
+    "socket": "bunx socket optimize",
     "test": "bun test",
+    "test:bench": "bun --config=./bunfig.bench.toml test ./bench/test/",
     "typecheck": "tsc --noEmit"
   },
   "lint-staged": {
     "*.{json,jsonc,ts}": "bun run lint:fix --"
   },
+  "resolutions": {
+    "is-unicode-supported": "npm:@socketregistry/is-unicode-supported@^1",
+    "safe-buffer": "npm:@socketregistry/safe-buffer@^1"
+  },
   "overrides": {
     "brace-expansion": "5.0.9",
+    "is-unicode-supported": "npm:@socketregistry/is-unicode-supported@^1",
+    "safe-buffer": "npm:@socketregistry/safe-buffer@^1",
     "undici": "8.9.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.11",
+    "@biomejs/biome": "2.5.12",
     "@earendil-works/pi-ai": "^0.84.4",
     "@earendil-works/pi-coding-agent": "^0.84.4",
     "@earendil-works/pi-tui": "^0.84.4",
-    "@types/node": "^26.4.0",
-    "bun-types": "1.3.14",
+    "@types/node": "^26.4.1",
+    "bun-types": "1.4.1",
     "husky": "^9.1.7",
     "lint-staged": "^17.4.1",
-    "typebox": "^1.3.21",
+    "typebox": "^1.3.25",
     "typescript": "^7.0.2",
-    "ultracite": "7.10.7"
+    "ultracite": "7.10.8"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.1",

package/src/commands.ts

@@ -14,6 +14,7 @@ import {
   executorRef,
   getAdvisorMaxCallsPerSession,
   getAdvisorSettings,
+  getPersistedModelRefs,
   isSimpleMode,
   loadConfig,
   parseArgs,
@@ -65,6 +66,7 @@ import {
   renderAdvisorCallBox,
   renderAdvisorResponseHeader,
   renderScoutDetails,
+  renderThinkingMarkdown,
   resolveAdvisorRequest,
   ScoutStatusManager,
   type ScoutToolDetails,
@@ -111,6 +113,20 @@ const selectedEffort = (choice: string): string | undefined => {
     : choice;
   return effort === DEFAULT_EFFORT_LEVEL ? undefined : effort;
 };
+const ADVISOR_ACTIVATION_EXPLANATION =
+  "The Advisor is a second-opinion model that reviews the Executor's context and returns risks, alternatives, and verification steps without changing files or running tools.";
+const ARGUMENT_WHITESPACE = /\s+/;
+const hasModelOverride = (args: string, key: "advisor" | "executor") =>
+  args
+    .trim()
+    .split(ARGUMENT_WHITESPACE)
+    .some((token) => {
+      const [tokenKey, value] = token.split("=");
+      return tokenKey === key && Boolean(value);
+    });
+const hasExecutorOverride = (args: string) =>
+  hasModelOverride(args, "executor");
+const hasAdvisorOverride = (args: string) => hasModelOverride(args, "advisor");
 
 const CONTEXT_PRESETS: ContextPreset[] = [
   {
@@ -246,16 +262,9 @@ class ManualAdvisorProgressComponent implements Component {
         0
       )
     );
-    if (this.state.thinking) {
+    if (this.state.thinking?.trim()) {
       box.addChild(
-        new Text(
-          this.theme.fg(
-            "thinkingText",
-            `  💭 ${this.state.thinking.replace(/\n/g, " ").slice(-200)}`
-          ),
-          0,
-          0
-        )
+        renderThinkingMarkdown(this.state.thinking.slice(-200), this.theme)
       );
     }
     if (this.state.text) {
@@ -276,11 +285,205 @@ class ManualAdvisorProgressComponent implements Component {
   }
 }
 
-const findConfiguredModel = (ctx: ExtensionContext, ref: string) => {
+const findConfiguredModel = (
+  ctx: ExtensionContext,
+  ref: string | undefined
+) => {
+  if (!ref) {
+    return;
+  }
   const [provider, modelId] = splitRef(ref);
   return ctx.modelRegistry.find(provider, modelId);
 };
 
+const getAvailableModelRefs = (ctx: ExtensionContext): string[] | undefined => {
+  if (typeof ctx.modelRegistry.getAvailable !== "function") {
+    return undefined;
+  }
+  return ctx.modelRegistry
+    .getAvailable()
+    .map((model) => `${model.provider}/${model.id}`);
+};
+
+const isSelectableModel = (
+  ctx: ExtensionContext,
+  ref: string | undefined,
+  availableRefs: Set<string> | undefined
+) => {
+  if (!ref) {
+    return false;
+  }
+  if (availableRefs) {
+    const [provider, modelId] = splitRef(ref);
+    return availableRefs.has(`${provider}/${modelId}`);
+  }
+  return Boolean(findConfiguredModel(ctx, ref));
+};
+
+const getExplicitModelError = (
+  ctx: ExtensionContext,
+  ref: string | undefined,
+  label: "Advisor" | "Executor",
+  overridden: boolean,
+  availableRefs: Set<string> | undefined
+) => {
+  if (overridden) {
+    if (!ref) {
+      return `${label} model not configured`;
+    }
+    if (!findConfiguredModel(ctx, ref)) {
+      return `${label} model not found: ${ref}`;
+    }
+    if (availableRefs && !isSelectableModel(ctx, ref, availableRefs)) {
+      return `${label} model unavailable: ${ref}`;
+    }
+  }
+};
+
+interface ActivationModelPlan {
+  pendingExecutor: string | undefined;
+  selectAdvisor: boolean;
+  selectExecutor: boolean;
+}
+
+const planActivationModels = (
+  ctx: ExtensionContext,
+  executor: string | undefined,
+  advisor: string | undefined,
+  pendingExecutorRef: string | undefined,
+  persisted: ReturnType<typeof getPersistedModelRefs>,
+  executorOverride: boolean,
+  advisorOverride: boolean,
+  availableRefs: Set<string> | undefined
+): ActivationModelPlan => {
+  const pendingExecutor =
+    !executorOverride &&
+    pendingExecutorRef &&
+    isSelectableModel(ctx, pendingExecutorRef, availableRefs)
+      ? pendingExecutorRef
+      : undefined;
+  const executorConfigured =
+    executorOverride ||
+    Boolean(pendingExecutor) ||
+    Boolean(
+      persisted.executor && isSelectableModel(ctx, executor, availableRefs)
+    );
+  const advisorConfigured =
+    advisorOverride ||
+    Boolean(
+      persisted.advisor && isSelectableModel(ctx, advisor, availableRefs)
+    );
+  return {
+    pendingExecutor,
+    selectAdvisor: !advisorConfigured,
+    selectExecutor: !executorConfigured,
+  };
+};
+
+interface AdvisorModelSelection {
+  advisor: string;
+  advisorEffort: string | undefined;
+  executor: string;
+  executorEffort: string | undefined;
+}
+
+interface AdvisorModelPickerOptions {
+  advisor: string | undefined;
+  advisorEffort: string | undefined;
+  executor: string | undefined;
+  executorEffort: string | undefined;
+  selectAdvisor: boolean;
+  selectExecutor: boolean;
+}
+
+const selectAdvisorModels = async (
+  ctx: ExtensionContext,
+  options: AdvisorModelPickerOptions
+): Promise<AdvisorModelSelection | undefined> => {
+  if (!ctx.hasUI) {
+    return undefined;
+  }
+  const refs = getAvailableModelRefs(ctx);
+  if (refs && refs.length === 0) {
+    notify(
+      ctx,
+      "No selectable models are available. Configure a provider with /login or models.json, then retry.",
+      "error"
+    );
+    return undefined;
+  }
+  const allOptions = [
+    ...new Set(
+      refs ??
+        [options.executor, options.advisor].filter((ref): ref is string =>
+          Boolean(ref)
+        )
+    ),
+  ];
+  let { advisor, advisorEffort, executor, executorEffort } = options;
+
+  if (options.selectExecutor) {
+    const selectedExecutor = await ctx.ui.custom<string | undefined>(
+      (tui, theme, keybindings, done) =>
+        new SearchableModelSelector({
+          allOptions,
+          currentOption: executor || undefined,
+          keybindings,
+          onCancel: () => done(undefined),
+          onSelect: done,
+          theme,
+          title: "Select Executor Model",
+          tui,
+        })
+    );
+    if (!selectedExecutor) {
+      return undefined;
+    }
+    const selectedExecutorEffort = await ctx.ui.select(
+      "Select Executor Reasoning/Thinking Level",
+      effortChoices(executorEffort)
+    );
+    if (!selectedExecutorEffort) {
+      return undefined;
+    }
+    executor = selectedExecutor;
+    executorEffort = selectedEffort(selectedExecutorEffort);
+  }
+
+  if (options.selectAdvisor) {
+    const selectedAdvisor = await ctx.ui.custom<string | undefined>(
+      (tui, theme, keybindings, done) =>
+        new SearchableModelSelector({
+          allOptions,
+          currentOption: advisor || undefined,
+          keybindings,
+          onCancel: () => done(undefined),
+          onSelect: done,
+          theme,
+          title: "Select Advisor Model",
+          tui,
+        })
+    );
+    if (!selectedAdvisor) {
+      return undefined;
+    }
+    const selectedAdvisorEffort = await ctx.ui.select(
+      "Select Advisor Reasoning/Thinking Level",
+      effortChoices(advisorEffort)
+    );
+    if (!selectedAdvisorEffort) {
+      return undefined;
+    }
+    advisor = selectedAdvisor;
+    advisorEffort = selectedEffort(selectedAdvisorEffort);
+  }
+
+  if (!(advisor && executor)) {
+    return undefined;
+  }
+  return { advisor, advisorEffort, executor, executorEffort };
+};
+
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
 const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAdvisorEffortRef(
@@ -320,7 +523,11 @@ const saveAdvisorSettings = (
   settings: AdvisorSettings
 ) => {
   applyAdvisorSettings(settings);
-  saveConfig(ctx);
+  const persisted = getPersistedModelRefs();
+  saveConfig(ctx, {
+    persistAdvisor: Boolean(persisted.advisor),
+    persistExecutor: Boolean(persisted.executor),
+  });
   saveGlobalOutcomeLogging(settings.outcomeLogging ?? false);
 };
 
@@ -353,6 +560,22 @@ export const registerCommands = (
         onScout,
         undefined
       ));
+  // Pi's model_select event reports both built-in `/model` changes and direct
+  // pi.setModel() calls. Keep an inactive user selection transiently so
+  // `/advisor` can adopt it without treating every normal model change as a
+  // global default. The suppression flag covers this extension's own restore.
+  let pendingExecutorModelRef: string | undefined;
+  let suppressModelSelectionSync = false;
+  const setExecutorModel = async (
+    model: Parameters<ExtensionAPI["setModel"]>[0]
+  ) => {
+    suppressModelSelectionSync = true;
+    try {
+      return await pi.setModel(model);
+    } finally {
+      suppressModelSelectionSync = false;
+    }
+  };
   const manualConsultations = new Map<AbortController, symbol>();
   const manualProgressTimers = new Map<
     AbortController,
@@ -518,17 +741,25 @@ export const registerCommands = (
   const resolveActivationModels = async (ctx: ExtensionContext) => {
     const executor = findConfiguredModel(ctx, executorRef);
     if (!executor) {
-      return { error: `Executor model not found: ${executorRef}` };
+      return {
+        error: executorRef
+          ? `Executor model not found: ${executorRef}`
+          : "Executor model not configured",
+      };
     }
     const advisor = findConfiguredModel(ctx, advisorRef);
     if (!advisor) {
-      return { error: `Advisor model not found: ${advisorRef}` };
+      return {
+        error: advisorRef
+          ? `Advisor model not found: ${advisorRef}`
+          : "Advisor model not configured",
+      };
     }
     const advisorAuth = await ctx.modelRegistry.getApiKeyAndHeaders(advisor);
     if (!(advisorAuth.ok && advisorAuth.apiKey)) {
       return { error: `No API key for Advisor ${advisorRef}` };
     }
-    if (!(await pi.setModel(executor))) {
+    if (!(await setExecutorModel(executor))) {
       return { error: `No API key for Executor ${executorRef}` };
     }
     return {};
@@ -549,6 +780,83 @@ export const registerCommands = (
     }
   };
 
+  const prepareActivationModels = async (
+    ctx: ExtensionContext,
+    announce: boolean,
+    executorOverride: boolean,
+    advisorOverride: boolean
+  ): Promise<
+    { pickedModels: boolean; pendingExecutor?: string } | undefined
+  > => {
+    const persisted = getPersistedModelRefs();
+    const availableRefs = getAvailableModelRefs(ctx);
+    const availableRefSet = availableRefs ? new Set(availableRefs) : undefined;
+    const explicitError =
+      getExplicitModelError(
+        ctx,
+        executorRef,
+        "Executor",
+        executorOverride,
+        availableRefSet
+      ) ??
+      getExplicitModelError(
+        ctx,
+        advisorRef,
+        "Advisor",
+        advisorOverride,
+        availableRefSet
+      );
+    if (explicitError) {
+      notify(ctx, explicitError, "error");
+      return;
+    }
+
+    const plan = planActivationModels(
+      ctx,
+      executorRef,
+      advisorRef,
+      pendingExecutorModelRef,
+      persisted,
+      executorOverride,
+      advisorOverride,
+      availableRefSet
+    );
+    setExecutorRef(plan.pendingExecutor ?? executorRef);
+    if (!(plan.selectExecutor || plan.selectAdvisor)) {
+      return { pendingExecutor: plan.pendingExecutor, pickedModels: false };
+    }
+
+    // Always-on startup cannot open an interactive picker, so it leaves the
+    // flow disabled until the user selects both models with `/advisor`.
+    if (!announce) {
+      notify(
+        ctx,
+        "Advisor models are not configured or available. Run /advisor to choose them.",
+        "error"
+      );
+      return;
+    }
+    const selection = await selectAdvisorModels(ctx, {
+      advisor: advisorOverride || persisted.advisor ? advisorRef : "",
+      advisorEffort: advisorEffortRef,
+      executor:
+        executorOverride || plan.pendingExecutor || persisted.executor
+          ? executorRef
+          : "",
+      executorEffort: executorEffortRef,
+      selectAdvisor: plan.selectAdvisor,
+      selectExecutor: plan.selectExecutor,
+    });
+    if (!selection) {
+      return;
+    }
+    setAdvisorRef(selection.advisor);
+    setAdvisorEffortRef(selection.advisorEffort);
+    setExecutorRef(selection.executor);
+    setExecutorEffortRef(selection.executorEffort);
+    return { pendingExecutor: plan.pendingExecutor, pickedModels: true };
+  };
+
   const activateAdvisor = async (
     args: string,
     ctx: ExtensionContext,
@@ -559,32 +867,53 @@ export const registerCommands = (
     }
     const previous = {
       advisor: advisorRef,
+      advisorEffort: advisorEffortRef,
       contextMaxChars: contextMaxCharsRef,
       executor: executorRef,
+      executorEffort: executorEffortRef,
     };
     const restoreRefs = () => {
       setAdvisorRef(previous.advisor);
+      setAdvisorEffortRef(previous.advisorEffort);
       setContextMaxCharsRef(previous.contextMaxChars);
       setExecutorRef(previous.executor);
+      setExecutorEffortRef(previous.executorEffort);
     };
+    const executorOverride = hasExecutorOverride(args);
+    const advisorOverride = hasAdvisorOverride(args);
     const argumentError = parseArgs(args);
     if (argumentError) {
       restoreRefs();
       notify(ctx, argumentError, "error");
       return;
     }
+
+    const prepared = await prepareActivationModels(
+      ctx,
+      announce,
+      executorOverride,
+      advisorOverride
+    );
+    if (!prepared) {
+      restoreRefs();
+      return;
+    }
     const { error } = await resolveActivationModels(ctx);
     if (error) {
       restoreRefs();
       notify(ctx, error, "error");
       return;
     }
-    // parseArgs only mutates in-memory refs, and every later loadConfig resets
-    // them from disk. Persist supplied arguments once they are known to resolve,
+    // parseArgs, model picking, and an inactive `/model` selection only mutate
+    // in-memory refs. Persist them once both models are known and authenticated,
     // so an unusable model reference is never written to the configuration.
-    if (args.trim()) {
-      saveConfig(ctx);
+    if (args.trim() || prepared.pickedModels || prepared.pendingExecutor) {
+      saveConfig(ctx, { persistAdvisor: true, persistExecutor: true });
     }
+    // A successful activation has committed the effective Executor. Do not let
+    // an older inactive selection override an explicit activation argument on a
+    // later attempt.
+    pendingExecutorModelRef = undefined;
     if (executorEffortRef) {
       pi.setThinkingLevel(executorEffortRef as ThinkingLevel);
     }
@@ -598,7 +927,7 @@ export const registerCommands = (
     if (announce) {
       notify(
         ctx,
-        `Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
+        `${ADVISOR_ACTIVATION_EXPLANATION}\n\nAdvisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
         "info"
       );
     }
@@ -665,6 +994,7 @@ export const registerCommands = (
   );
 
   pi.on("session_start", async (_event, ctx) => {
+    pendingExecutorModelRef = undefined;
     // A malformed advisor.json or a provider auth failure must not reject a
     // lifecycle handler and break session startup.
     try {
@@ -679,17 +1009,29 @@ export const registerCommands = (
   });
 
   pi.on("model_select", (event, ctx) => {
-    // Only an explicit user selection redefines the Executor. "restore" replays a
-    // stored session model and would otherwise overwrite saved configuration.
-    if (event.source !== "set" || !flowEnabled()) {
+    // "restore" replays a stored session model and "cycle" changes the active
+    // model without an explicit `/model` choice. Neither should redefine the
+    // configured Executor.
+    if (event.source !== "set" || suppressModelSelectionSync) {
       return;
     }
     const selected = `${event.model.provider}/${event.model.id}`;
+    if (!flowEnabled()) {
+      // Defer persistence until `/advisor` succeeds. This keeps ordinary model
+      // selection global defaults untouched when the flow is not enabled.
+      pendingExecutorModelRef = selected;
+      return;
+    }
+    pendingExecutorModelRef = undefined;
     if (selected === executorRef) {
       return;
     }
+    const persisted = getPersistedModelRefs();
     setExecutorRef(selected);
-    saveConfig(ctx);
+    saveConfig(ctx, {
+      persistAdvisor: Boolean(persisted.advisor),
+      persistExecutor: true,
+    });
   });
 
   pi.on("session_shutdown", (_event, ctx) => {
@@ -805,7 +1147,7 @@ export const registerCommands = (
 
   pi.registerCommand("advisor", {
     description:
-      "Enable the Executor/Advisor flow and switch to the configured Executor model; accepts contextMaxChars=N",
+      "Enable the Executor/Advisor flow and switch to the configured or explicitly selected Executor model; accepts contextMaxChars=N",
     handler: (args, ctx) => activateAdvisor(args, ctx),
   });
 
@@ -816,66 +1158,33 @@ export const registerCommands = (
       if (!(loadCommandConfig(ctx) && ctx.hasUI)) {
         return;
       }
-      const refs = ctx.modelRegistry
-        .getAvailable()
-        .map((m) => `${m.provider}/${m.id}`);
-
-      const executor = await ctx.ui.custom<string | undefined>(
-        (tui, theme, keybindings, done) =>
-          new SearchableModelSelector({
-            allOptions: refs,
-            currentOption: executorRef,
-            keybindings,
-            onCancel: () => done(undefined),
-            onSelect: done,
-            theme,
-            title: "Select Executor Model",
-            tui,
-          })
-      );
-      if (!executor) {
-        return;
-      }
-
-      const executorEffort = await ctx.ui.select(
-        "Select Executor Reasoning/Thinking Level",
-        effortChoices(executorEffortRef)
-      );
-      if (!executorEffort) {
-        return;
-      }
-
-      const advisor = await ctx.ui.custom<string | undefined>(
-        (tui, theme, keybindings, done) =>
-          new SearchableModelSelector({
-            allOptions: refs,
-            currentOption: advisorRef,
-            keybindings,
-            onCancel: () => done(undefined),
-            onSelect: done,
-            theme,
-            title: "Select Advisor Model",
-            tui,
-          })
-      );
-      if (!advisor) {
-        return;
-      }
-
-      const advisorEffort = await ctx.ui.select(
-        "Select Advisor Reasoning/Thinking Level",
-        effortChoices(advisorEffortRef)
-      );
-      if (!advisorEffort) {
+      // When `/model` was used before activation, show that session choice as
+      // the Executor's current option instead of making the persisted Executor
+      // look like the active selection.
+      const persisted = getPersistedModelRefs();
+      const selection = await selectAdvisorModels(ctx, {
+        advisor: persisted.advisor ? advisorRef : "",
+        advisorEffort: advisorEffortRef,
+        executor:
+          pendingExecutorModelRef ?? (persisted.executor ? executorRef : ""),
+        executorEffort: executorEffortRef,
+        selectAdvisor: true,
+        selectExecutor: true,
+      });
+      if (!selection) {
         return;
       }
 
-      setExecutorRef(executor);
-      setAdvisorRef(advisor);
-      setExecutorEffortRef(selectedEffort(executorEffort));
-      setAdvisorEffortRef(selectedEffort(advisorEffort));
+      setExecutorRef(selection.executor);
+      setAdvisorRef(selection.advisor);
+      setExecutorEffortRef(selection.executorEffort);
+      setAdvisorEffortRef(selection.advisorEffort);
 
-      const path = saveConfig(ctx);
+      const path = saveConfig(ctx, {
+        persistAdvisor: true,
+        persistExecutor: true,
+      });
+      pendingExecutorModelRef = undefined;
       ctx.ui.notify(
         `Saved Executor + Advisor configurations to ${path}`,
         "info"
@@ -932,8 +1241,12 @@ export const registerCommands = (
       // Leaving alwaysOn set would silently reactivate the flow next session.
       const wasAlwaysOn = alwaysOnRef;
       if (wasAlwaysOn) {
+        const persisted = getPersistedModelRefs();
         setAlwaysOnRef(false);
-        saveConfig(ctx);
+        saveConfig(ctx, {
+          persistAdvisor: Boolean(persisted.advisor),
+          persistExecutor: Boolean(persisted.executor),
+        });
       }
       notify(
         ctx,

package/src/config.ts

@@ -13,8 +13,6 @@ import {
   isValidGitContextLevel,
 } from "./git.js";
 
-export const FALLBACK_EXECUTOR = "openai-codex/gpt-5.6-luna";
-export const FALLBACK_ADVISOR = "openai-codex/gpt-5.6-sol";
 export const DEFAULT_CONTEXT_MAX_CHARS = 15_000;
 export const MAX_CONTEXT_MAX_CHARS = Number.MAX_SAFE_INTEGER;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = DEFAULT_MAX_LINES;
@@ -37,8 +35,11 @@ export const GATE_FAILURE_MODES: GateFailureMode[] = [
   "warn-and-continue",
 ];
 
-export let executorRef = FALLBACK_EXECUTOR;
-export let advisorRef = FALLBACK_ADVISOR;
+// An empty ref means no model has been selected yet.
+export let executorRef = "";
+export let advisorRef = "";
+let persistedExecutorRef: string | undefined;
+let persistedAdvisorRef: string | undefined;
 export let executorEffortRef: string | undefined;
 export let advisorEffortRef: string | undefined;
 export let contextMaxCharsRef = DEFAULT_CONTEXT_MAX_CHARS;
@@ -75,6 +76,11 @@ export const setExecutorRef = (ref: string) => {
 export const setAdvisorRef = (ref: string) => {
   advisorRef = ref;
 };
+/** Returns model refs explicitly persisted in the global Advisor config. */
+export const getPersistedModelRefs = () => ({
+  advisor: persistedAdvisorRef,
+  executor: persistedExecutorRef,
+});
 export const setExecutorEffortRef = (effort: string | undefined) => {
   executorEffortRef = effort;
 };
@@ -469,8 +475,10 @@ export const validateConfig = (
 };
 
 const resetDefaults = () => {
-  executorRef = FALLBACK_EXECUTOR;
-  advisorRef = FALLBACK_ADVISOR;
+  executorRef = "";
+  advisorRef = "";
+  persistedExecutorRef = undefined;
+  persistedAdvisorRef = undefined;
   executorEffortRef = undefined;
   advisorEffortRef = undefined;
   contextMaxCharsRef = DEFAULT_CONTEXT_MAX_CHARS;
@@ -522,6 +530,9 @@ const applyNonEmptyStringConfig = (
   }
 };
 
+const configuredModelRef = (value: string | undefined): string | undefined =>
+  value?.trim() || undefined;
+
 const applyConfig = (config: AdvisorConfig) => {
   applyNonEmptyStringConfig(config.executor, setExecutorRef);
   applyNonEmptyStringConfig(config.advisor, setAdvisorRef);
@@ -667,6 +678,8 @@ export const loadConfig = (_ctx: ExtensionContext) => {
   const globalConfig = existsSync(global)
     ? readConfigCached(global)
     : undefined;
+  persistedExecutorRef = configuredModelRef(globalConfig?.executor);
+  persistedAdvisorRef = configuredModelRef(globalConfig?.advisor);
   if (globalConfig) {
     applyConfig(globalConfig);
     const unknownKeys = unknownConfigKeys(globalConfig as ConfigRecord);
@@ -691,8 +704,18 @@ export const loadConfig = (_ctx: ExtensionContext) => {
 };
 
 /** Saves user-controlled configuration globally without outcome consent. */
-export const saveConfig = (_ctx: ExtensionContext) => {
+export interface SaveConfigOptions {
+  persistAdvisor?: boolean;
+  persistExecutor?: boolean;
+}
+
+export const saveConfig = (
+  _ctx: ExtensionContext,
+  options: SaveConfigOptions = {}
+) => {
   const path = join(getAgentDir(), "advisor.json");
+  const persistAdvisor = options.persistAdvisor ?? true;
+  const persistExecutor = options.persistExecutor ?? true;
   let existing: Record<string, unknown> = {};
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -707,7 +730,7 @@ export const saveConfig = (_ctx: ExtensionContext) => {
   }
   const data = {
     ...existing,
-    advisor: advisorRef,
+    ...(persistAdvisor && advisorRef ? { advisor: advisorRef } : {}),
     advisorAutoLoopGate: advisorAutoLoopGateRef,
     advisorBlockOnBlocked: advisorBlockOnBlockedRef,
     advisorCollapseResponses: advisorCollapseResponsesRef,
@@ -718,7 +741,7 @@ export const saveConfig = (_ctx: ExtensionContext) => {
     advisorLoopThreshold: advisorLoopThresholdRef,
     advisorPlanGate: advisorPlanGateRef,
     contextMaxChars: contextMaxCharsRef,
-    executor: executorRef,
+    ...(persistExecutor && executorRef ? { executor: executorRef } : {}),
     executorEffort: executorEffortRef,
     ...(advisorMaxCallsPerSessionRef === undefined
       ? {}

package/src/model-stream.ts

@@ -18,9 +18,12 @@ export interface ResolvedConfiguredModel {
 
 export const resolveConfiguredModel = async (
   ctx: ExtensionContext,
-  ref: string,
+  ref: string | undefined,
   label: string
 ): Promise<ResolvedConfiguredModel> => {
+  if (!ref) {
+    throw new Error(`${label} model not configured`);
+  }
   const [provider, modelId] = splitRef(ref);
   const model = ctx.modelRegistry.find(provider, modelId);
   if (!model) {
@@ -193,7 +196,13 @@ export const collectTextStream = async (
       apiKey: resolved.apiKey,
       env: resolved.env,
       headers: resolved.headers,
+      // `stream()` uses the provider-facing name while the extension's public
+      // option keeps the Pi-facing `reasoning` name. Preserve both so the
+      // configured effort reaches providers that serialize reasoning_effort.
       reasoning: options.reasoning as never,
+      ...(options.reasoning === undefined
+        ? {}
+        : { reasoningEffort: options.reasoning as never }),
       signal: options.signal,
     }
   );

package/src/tools.ts

@@ -10,7 +10,14 @@ import {
   type ToolCallEventResult,
   type ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
-import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import {
+  Box,
+  type Component,
+  Markdown,
+  Text,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
   advisorAutoLoopGateRef,
@@ -111,6 +118,56 @@ export const SPINNER_FRAMES = [
   "⠇",
   "⠏",
 ];
+
+const THINKING_PREFIX = "  💭 ";
+const THINKING_PREFIX_WIDTH = visibleWidth(THINKING_PREFIX);
+type ThinkingTheme = Pick<Theme, "fg">;
+
+/**
+ * Renders visible nested-model thinking with the same Markdown semantics as
+ * Pi's assistant thinking blocks while keeping the compact speech-bubble cue.
+ * The prefix is added after Markdown parsing so it cannot change block syntax.
+ *
+ * Note: During streaming, incomplete Markdown (e.g., `**text` without closing `**`)
+ * displays raw markers transiently until delimiters arrive. This mirrors expected
+ * behavior when typing Markdown incrementally and is acceptable in the context
+ * of brief thinking previews. When thinking is complete, all markers render.
+ */
+class ThinkingMarkdown implements Component {
+  private readonly markdown: Markdown;
+  private readonly prefix: string;
+
+  constructor(thinking: string, theme: ThinkingTheme) {
+    this.markdown = new Markdown(thinking.trim(), 0, 0, getMarkdownTheme(), {
+      color: (text) => theme.fg("thinkingText", text),
+      italic: true,
+    });
+    this.prefix = theme.fg("thinkingText", THINKING_PREFIX);
+  }
+
+  render(width: number): string[] {
+    const renderWidth = Math.max(1, Math.floor(width));
+    const contentWidth = Math.max(1, renderWidth - THINKING_PREFIX_WIDTH);
+    const lines = this.markdown.render(contentWidth);
+    return lines.map((line, index) =>
+      truncateToWidth(
+        index === 0 ? `${this.prefix}${line}` : line,
+        renderWidth,
+        ""
+      )
+    );
+  }
+
+  invalidate(): void {
+    this.markdown.invalidate();
+  }
+}
+
+export const renderThinkingMarkdown = (
+  thinking: string,
+  theme: ThinkingTheme
+): Component => new ThinkingMarkdown(thinking, theme);
+
 export const resolveAdvisorRequest = (question?: string) =>
   question?.trim() || undefined;
 export const advisorMessageText = (
@@ -1214,21 +1271,19 @@ export const renderScoutDetails = (
   if (scout.fallbackReason) {
     lines.push(theme.fg("warning", `  ${scout.fallbackReason}`));
   }
-  if (scout.thinking && active) {
-    lines.push(
-      theme.fg(
-        "thinkingText",
-        `  💭 ${scout.thinking.replace(/\n/g, " ").slice(-200)}`
-      )
-    );
+  const thinking = scout.thinking && active ? scout.thinking.slice(-200) : "";
+  box.addChild(new Text(lines.join("\n"), 0, 0));
+  if (thinking.trim()) {
+    box.addChild(renderThinkingMarkdown(thinking, theme));
   }
+  const expandedLines: string[] = [];
   if (expanded && scout.selectedLabels?.length) {
-    lines.push(
+    expandedLines.push(
       theme.fg("dim", `  Selected: ${scout.selectedLabels.join("; ")}`)
     );
   }
   if (expanded && scout.synthesis) {
-    lines.push(
+    expandedLines.push(
       theme.fg(
         "dim",
         `  Scout synthesis (untrusted inference): ${scout.synthesis}`
@@ -1236,14 +1291,16 @@ export const renderScoutDetails = (
     );
   }
   if (expanded && scout.omittedBeforeScout) {
-    lines.push(
+    expandedLines.push(
       theme.fg(
         "dim",
         `  ${scout.omittedBeforeScout} group(s) omitted before Scout`
       )
     );
   }
-  box.addChild(new Text(lines.join("\n"), 0, 0));
+  if (expandedLines.length > 0) {
+    box.addChild(new Text(expandedLines.join("\n"), 0, 0));
+  }
 };
 
 const syncRenderPhase = (context: AdvisorToolContext, phase: string) => {
@@ -1283,14 +1340,14 @@ const renderPartialAdvisorResult = (
   const lines = [
     `${theme.fg("warning", theme.bold(`◆ ADVISOR ${frame}`))} ${theme.fg("dim", "· Working…")}`,
   ];
-  if (details?.thinking) {
+  box.addChild(new Text(lines.join("\n"), 0, 0));
+  if (details?.thinking?.trim()) {
     const thought =
       details.thinking.length > 200
         ? details.thinking.slice(-200)
         : details.thinking;
-    lines.push(theme.fg("thinkingText", `  💭 ${thought.replace(/\n/g, " ")}`));
+    box.addChild(renderThinkingMarkdown(thought, theme));
   }
-  box.addChild(new Text(lines.join("\n"), 0, 0));
   if (details?.text) {
     box.addChild(
       new Markdown(
@@ -1354,17 +1411,14 @@ const renderFinalAdvisorResult = (
   if (attachments.length) {
     lines.push(theme.fg("dim", `  ${attachments.join(" · ")}`));
   }
-  if (details?.thinking) {
-    const thought = details.thinking.replace(/\n/g, " ").slice(0, 300);
-    lines.push(
-      theme.fg(
-        "thinkingText",
-        `  💭 ${thought}${details.thinking.length > 300 ? "…" : ""}`
-      )
-    );
-  }
+  const thinking = details?.thinking?.trim()
+    ? `${details.thinking.slice(0, 300)}${details.thinking.length > 300 ? "…" : ""}`
+    : "";
   const displayAdvice = advice || "(Advisor returned no advice.)";
   box.addChild(new Text(lines.join("\n"), 0, 0));
+  if (thinking) {
+    box.addChild(renderThinkingMarkdown(thinking, theme));
+  }
   box.addChild(
     new Markdown(
       adviceForDisplay(displayAdvice, expanded),