pi-advisor-flow 0.2.3 → 0.2.4

package/README.md

@@ -36,7 +36,7 @@ Restart or reload Pi after installation, then run `/advisor` in a session.
 
 1. Run `/advisor` to enable the flow and register `ask_advisor`.
 2. Run `/advisor-models` to choose the Executor and Advisor models.
-3. Run `/advisor-settings` to set context, gates, privacy controls, and output limits.
+3. Run `/advisor-settings` to set Simple mode, persistent activation, context, gates, privacy controls, and output limits.
 
 Enable with models in one command when preferred:
 
@@ -62,7 +62,7 @@ The Executor calls `ask_advisor({})` for a general review of the current task an
 
 Use the Advisor after the Executor has investigated and formed a candidate direction. It is intended to challenge assumptions, expose risks, and confirm the next verification step—not to replace the Executor's work.
 
-Normal consultations preserve the provider's final Markdown. They do not parse a verdict or block execution.
+Normal consultations preserve the provider's final Markdown and never block execution. When the Advisor has no material concern or recommendation, it may begin with the exact first line `Verdict: sound`; Pi renders that response with the static `◆ ADVISOR · SOUND` header, for both `ask_advisor` results and `/advisor-manual`.
 
 ## Automatic loop gate
 
@@ -125,7 +125,9 @@ All fields are optional. This example shows the available settings and their nor
   "advisorBlockOnBlocked": true,
   "gateFailureMode": "block-session",
 
-  "advisorSessionSummary": true,
+  "advisorSessionSummary": false,
+  "simpleMode": false,
+  "alwaysOn": false,
   "advisorHerdrIntegration": true,
   "advisorToolResultMaxLines": 2000,
   "advisorToolResultMaxBytes": 51200,
@@ -138,6 +140,12 @@ All fields are optional. This example shows the available settings and their nor
 }
 ```
 
+### Simple mode and persistent activation
+
+- `simpleMode` defaults to `false`. When enabled, `ask_advisor` and `/advisor-manual` remain available for voluntary second opinions, while plan/failure/completion rules, loop gates, blocking, call budgets, and session summaries are disabled. Context limits, result caps, redaction, and tool disclosure policies still apply.
+- `alwaysOn` defaults to `false`. When enabled, Pi restores the configured Executor and activates `ask_advisor` for new, resumed, forked, and reloaded sessions. While the Advisor flow is active, an explicit `/model` selection becomes the persisted Executor for the next activation; a model restored with a session does not change the saved Executor. `/advisor-off` turns `alwaysOn` off so the flow stays disabled in later sessions.
+- In Simple mode, settings keeps the Context window/history slider alongside Simple mode and Always on; advanced values remain saved and take effect when Simple mode is disabled.
+
 ### Context and limits
 
 - `contextMaxChars` defaults to `15000`. It preserves complete semantic entries and adds an omission marker rather than splitting a message.
@@ -161,7 +169,7 @@ Redaction and output limits reduce accidental disclosure; they are not a data-cl
 
 ### Session summary and Herdr
 
-The optional Session Advisor Summary is local and in-memory only. It appears after a non-blocked settled run and is never persisted.
+The optional Session Advisor Summary defaults to off. When enabled, it is local and in-memory only, appears after a non-blocked settled run, and is never persisted.
 
 It distinguishes regular Markdown advice from gate decisions and records the trigger, model, usage/cost when available, failures, budget, and execution effect.
 

package/package.json

@@ -32,7 +32,7 @@
     "*.{json,jsonc,ts}": "bun run lint:fix --"
   },
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/commands.ts

@@ -8,9 +8,11 @@ import {
   advisorEffortRef,
   advisorMaxCallsPerSessionRef,
   advisorRef,
+  alwaysOnRef,
   executorEffortRef,
   executorRef,
   getAdvisorSettings,
+  isSimpleMode,
   loadConfig,
   parseArgs,
   saveConfig,
@@ -32,9 +34,11 @@ import {
   setAdvisorToolPoliciesRef,
   setAdvisorToolResultMaxBytesRef,
   setAdvisorToolResultMaxLinesRef,
+  setAlwaysOnRef,
   setContextMaxCharsRef,
   setExecutorEffortRef,
   setExecutorRef,
+  setSimpleModeRef,
   splitRef,
 } from "./config.js";
 import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "./herdr.js";
@@ -42,7 +46,9 @@ import {
   adviceForDisplay,
   advisorSessionState,
   consultAdvisor,
+  hasSoundVerdict,
   renderAdvisorCallBox,
+  renderAdvisorResponseHeader,
   resolveAdvisorRequest,
 } from "./tools.js";
 import {
@@ -196,25 +202,47 @@ export const registerCommands = (
       });
   };
 
-  const activateAdvisor = async (args: string, ctx: ExtensionContext) => {
+  /** Resolves both models and their auth, or reports why activation cannot proceed. */
+  const resolveActivationModels = async (ctx: ExtensionContext) => {
+    const executor = findConfiguredModel(ctx, executorRef);
+    if (!executor) {
+      return { error: `Executor model not found: ${executorRef}` };
+    }
+    const advisor = findConfiguredModel(ctx, advisorRef);
+    if (!advisor) {
+      return { error: `Advisor model not found: ${advisorRef}` };
+    }
+    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))) {
+      return { error: `No API key for Executor ${executorRef}` };
+    }
+    return {};
+  };
+
+  const activateAdvisor = async (
+    args: string,
+    ctx: ExtensionContext,
+    announce = true
+  ) => {
     loadConfig(ctx);
     const argumentError = parseArgs(args);
     if (argumentError) {
       notify(ctx, argumentError, "error");
       return;
     }
-    const executor = findConfiguredModel(ctx, executorRef);
-    if (!executor) {
-      notify(ctx, `Executor model not found: ${executorRef}`, "error");
-      return;
-    }
-    if (!findConfiguredModel(ctx, advisorRef)) {
-      notify(ctx, `Advisor model not found: ${advisorRef}`, "error");
+    const { error } = await resolveActivationModels(ctx);
+    if (error) {
+      notify(ctx, error, "error");
       return;
     }
-    if (!(await pi.setModel(executor))) {
-      notify(ctx, `No API key for Executor ${executorRef}`, "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,
+    // so an unusable model reference is never written to the configuration.
+    if (args.trim()) {
+      saveConfig(ctx);
     }
     if (executorEffortRef) {
       pi.setThinkingLevel(executorEffortRef as ThinkingLevel);
@@ -222,11 +250,13 @@ export const registerCommands = (
     if (!flowEnabled()) {
       pi.setActiveTools([...pi.getActiveTools(), "ask_advisor"]);
     }
-    notify(
-      ctx,
-      `Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
-      "info"
-    );
+    if (announce) {
+      notify(
+        ctx,
+        `Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
+        "info"
+      );
+    }
   };
 
   pi.registerEntryRenderer?.(
@@ -244,17 +274,22 @@ export const registerCommands = (
         | { advisor?: string; text?: string }
         | undefined;
       const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-      box.addChild(
-        new Text(theme.fg("warning", theme.bold("◆ ADVISOR RESPONSE")), 0, 0)
-      );
-      if (details?.advisor) {
-        box.addChild(new Text(theme.fg("dim", `  ${details.advisor}`), 0, 0));
-      }
       const advice =
         details?.text ??
         (typeof message.content === "string"
           ? message.content
           : "(Advisor returned no advice.)");
+      // Manual consultations must render exactly like an Executor ask_advisor call.
+      box.addChild(
+        new Text(
+          renderAdvisorResponseHeader(hasSoundVerdict(advice), theme),
+          0,
+          0
+        )
+      );
+      if (details?.advisor) {
+        box.addChild(new Text(theme.fg("dim", `  ${details.advisor}`), 0, 0));
+      }
       box.addChild(
         new Markdown(
           adviceForDisplay(advice, expanded),
@@ -267,6 +302,34 @@ export const registerCommands = (
     }
   );
 
+  pi.on("session_start", async (_event, ctx) => {
+    // A malformed advisor.json or a provider auth failure must not reject a
+    // lifecycle handler and break session startup.
+    try {
+      loadConfig(ctx);
+      if (alwaysOnRef) {
+        await activateAdvisor("", ctx, false);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      notify(ctx, `Advisor activation failed: ${message}`, "error");
+    }
+  });
+
+  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()) {
+      return;
+    }
+    const selected = `${event.model.provider}/${event.model.id}`;
+    if (selected === executorRef) {
+      return;
+    }
+    setExecutorRef(selected);
+    saveConfig(ctx);
+  });
+
   pi.on("session_shutdown", () => {
     for (const controller of manualConsultations) {
       controller.abort();
@@ -280,13 +343,20 @@ export const registerCommands = (
       "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
     handler: (args, ctx) => {
       loadConfig(ctx);
-      if (!advisorSessionState.canConsult(advisorMaxCallsPerSessionRef)) {
+      if (
+        !(
+          isSimpleMode() ||
+          advisorSessionState.canConsult(advisorMaxCallsPerSessionRef)
+        )
+      ) {
         const message = "Advisor call budget exhausted for this session.";
         notify(ctx, message, "warning");
         notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
         return Promise.resolve();
       }
-      advisorSessionState.consumeCall();
+      if (!isSimpleMode()) {
+        advisorSessionState.consumeCall();
+      }
       const question = resolveAdvisorRequest(args);
       // A single visible progress surface avoids competing consultations overwriting
       // each other's streamed state. A newer manual request replaces the previous one.
@@ -427,7 +497,9 @@ export const registerCommands = (
       setAdvisorAutoLoopGateRef(settings.autoLoopGate ?? true);
       setAdvisorLoopThresholdRef(settings.loopThreshold ?? 3);
       setAdvisorMaxCallsPerSessionRef(settings.maxCallsPerSession);
-      setAdvisorSessionSummaryRef(settings.sessionSummary ?? true);
+      setAdvisorSessionSummaryRef(settings.sessionSummary ?? false);
+      setSimpleModeRef(settings.simpleMode ?? false);
+      setAlwaysOnRef(settings.alwaysOn ?? false);
       setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
       setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
       setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
@@ -445,12 +517,17 @@ export const registerCommands = (
       pi.setActiveTools(
         pi.getActiveTools().filter((name) => name !== "ask_advisor")
       );
-      if (ctx.hasUI) {
-        ctx.ui.notify(
-          "Advisor flow disabled. Current model unchanged.",
-          "info"
-        );
+      // Leaving alwaysOn set would silently reactivate the flow next session.
+      const wasAlwaysOn = alwaysOnRef;
+      if (wasAlwaysOn) {
+        setAlwaysOnRef(false);
+        saveConfig(ctx);
       }
+      notify(
+        ctx,
+        `Advisor flow disabled. Current model unchanged.${wasAlwaysOn ? " Always on turned off." : ""}`,
+        "info"
+      );
       return Promise.resolve();
     },
   });

package/src/config.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   CONFIG_DIR_NAME,
@@ -45,7 +45,9 @@ export let advisorBlockOnBlockedRef = true;
 export let advisorAutoLoopGateRef = true;
 export let advisorLoopThresholdRef = 3;
 export let advisorMaxCallsPerSessionRef: number | undefined;
-export let advisorSessionSummaryRef = true;
+export let advisorSessionSummaryRef = false;
+export let simpleModeRef = false;
+export let alwaysOnRef = false;
 export let advisorFailureModeRef: GateFailureMode = "block-session";
 export let advisorHerdrIntegrationRef = true;
 export let advisorToolResultMaxLinesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES;
@@ -107,6 +109,14 @@ export const setAdvisorMaxCallsPerSessionRef = (value: number | undefined) => {
 export const setAdvisorSessionSummaryRef = (enabled: boolean) => {
   advisorSessionSummaryRef = enabled;
 };
+export const setSimpleModeRef = (enabled: boolean) => {
+  simpleModeRef = enabled;
+};
+export const setAlwaysOnRef = (enabled: boolean) => {
+  alwaysOnRef = enabled;
+};
+/** Whether advanced Advisor automation is suppressed for this session. */
+export const isSimpleMode = () => simpleModeRef;
 export const isValidGateFailureMode = (
   value: unknown
 ): value is GateFailureMode =>
@@ -140,6 +150,7 @@ export const setAdvisorToolPoliciesRef = (policies: AdvisorToolPolicies) => {
  * imported mutable bindings, which can be snapshotted by extension loaders.
  */
 export const getAdvisorSettings = () => ({
+  alwaysOn: alwaysOnRef,
   autoLoopGate: advisorAutoLoopGateRef,
   blockOnBlocked: advisorBlockOnBlockedRef,
   collapseResponses: advisorCollapseResponsesRef,
@@ -155,6 +166,7 @@ export const getAdvisorSettings = () => ({
   planGate: advisorPlanGateRef,
   redactSecrets: advisorRedactSecretsRef,
   sessionSummary: advisorSessionSummaryRef,
+  simpleMode: simpleModeRef,
   toolPolicies: { ...advisorToolPoliciesRef },
   toolResultMaxBytes: advisorToolResultMaxBytesRef,
   toolResultMaxLines: advisorToolResultMaxLinesRef,
@@ -190,10 +202,12 @@ export interface AdvisorConfig {
   advisorToolPolicies?: AdvisorToolPolicies;
   advisorToolResultMaxBytes?: number;
   advisorToolResultMaxLines?: number;
+  alwaysOn?: boolean;
   contextMaxChars?: number;
   executor?: string;
   executorEffort?: string;
   gateFailureMode?: GateFailureMode;
+  simpleMode?: boolean;
 }
 
 const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
@@ -210,6 +224,8 @@ const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
   "advisorMaxCallsPerSession",
   "advisorPlanGate",
   "advisorSessionSummary",
+  "simpleMode",
+  "alwaysOn",
   "advisorToolResultMaxBytes",
   "advisorToolResultMaxLines",
   "advisorRedactSecrets",
@@ -227,6 +243,8 @@ const BOOLEAN_CONFIG_KEYS = [
   "advisorBlockOnBlocked",
   "advisorAutoLoopGate",
   "advisorSessionSummary",
+  "simpleMode",
+  "alwaysOn",
   "advisorHerdrIntegration",
   "advisorRedactSecrets",
 ] as const;
@@ -385,7 +403,9 @@ const resetDefaults = () => {
   advisorAutoLoopGateRef = true;
   advisorLoopThresholdRef = 3;
   advisorMaxCallsPerSessionRef = undefined;
-  advisorSessionSummaryRef = true;
+  advisorSessionSummaryRef = false;
+  simpleModeRef = false;
+  alwaysOnRef = false;
   advisorFailureModeRef = "block-session";
   advisorHerdrIntegrationRef = true;
   advisorToolResultMaxLinesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES;
@@ -458,6 +478,8 @@ const applyConfig = (config: AdvisorConfig) => {
     "advisorSessionSummary",
     setAdvisorSessionSummaryRef
   );
+  applyOptionalConfig(config, "simpleMode", setSimpleModeRef);
+  applyOptionalConfig(config, "alwaysOn", setAlwaysOnRef);
   applyOptionalConfig(config, "gateFailureMode", setAdvisorFailureModeRef);
   applyOptionalConfig(
     config,
@@ -492,6 +514,43 @@ const readConfig = (path: string): AdvisorConfig => {
   }
 };
 
+// loadConfig runs on every tool call and every consultation. Caching the parsed
+// file by path and stat identity removes that read and parse from the hot path
+// while still applying the full reset-then-apply sequence on each call.
+let configCache:
+  | { config: AdvisorConfig; identity: string; path: string }
+  | undefined;
+
+/** Drops the parsed-configuration cache; the next load re-reads from disk. */
+export const resetConfigCache = () => {
+  configCache = undefined;
+};
+
+/**
+ * Nanosecond timestamps plus size and inode so a same-millisecond or
+ * same-size external rewrite cannot be served from the cache. An unstattable
+ * path yields a unique value, which always forces a re-read.
+ */
+const configIdentity = (path: string): string => {
+  try {
+    const stats = statSync(path, { bigint: true });
+    return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}:${stats.ino}:${stats.dev}`;
+  } catch {
+    return `unstattable:${process.hrtime.bigint()}`;
+  }
+};
+
+const readConfigCached = (path: string): AdvisorConfig => {
+  const identity = configIdentity(path);
+  const cached = configCache;
+  if (cached && cached.path === path && cached.identity === identity) {
+    return cached.config;
+  }
+  const config = readConfig(path);
+  configCache = { config, identity, path };
+  return config;
+};
+
 export const loadConfig = (ctx: ExtensionContext) => {
   resetDefaults();
   const path = configPaths(ctx).find(
@@ -501,7 +560,7 @@ export const loadConfig = (ctx: ExtensionContext) => {
   if (!path) {
     return null;
   }
-  applyConfig(readConfig(path));
+  applyConfig(readConfigCached(path));
   return path;
 };
 
@@ -547,9 +606,12 @@ export const saveConfig = (ctx: ExtensionContext) => {
     advisorToolPolicies: advisorToolPoliciesRef,
     advisorToolResultMaxBytes: advisorToolResultMaxBytesRef,
     advisorToolResultMaxLines: advisorToolResultMaxLinesRef,
+    alwaysOn: alwaysOnRef,
     gateFailureMode: advisorFailureModeRef,
+    simpleMode: simpleModeRef,
   };
   writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+  resetConfigCache();
   return path;
 };
 

package/src/conversation.ts

@@ -256,10 +256,18 @@ const selectRecentEntries = (entries: string[], maxChars: number): string => {
     return joined;
   }
   const selected: string[] = [];
+  // Track the joined length instead of re-joining the accumulator each step;
+  // long branches with a large maxChars are otherwise quadratic in bytes.
+  let selectedLength = 0;
   for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const candidate = [entries[index], ...selected].join(separator);
-    if (candidate.length <= maxChars || selected.length === 0) {
-      selected.unshift(entries[index]);
+    const entry = entries[index];
+    const candidateLength =
+      selectedLength +
+      entry.length +
+      (selected.length === 0 ? 0 : separator.length);
+    if (candidateLength <= maxChars || selected.length === 0) {
+      selected.unshift(entry);
+      selectedLength = candidateLength;
     } else {
       break;
     }

package/src/tools.ts

@@ -30,6 +30,7 @@ import {
   advisorRef,
   advisorSessionSummaryRef,
   contextMaxCharsRef,
+  isSimpleMode,
   loadConfig,
   splitRef,
 } from "./config.js";
@@ -69,8 +70,15 @@ export const SPINNER_FRAMES = [
 ];
 export const resolveAdvisorRequest = (question?: string) =>
   question?.trim() || undefined;
-export const advisorMessageText = (conversation: string, question?: string) =>
-  `${conversation ? `<conversation>\n${conversation}\n</conversation>` : ""}${question ? `\n\nTargeted focus:\n${question}` : ""}`;
+export const advisorMessageText = (conversation: string, question?: string) => {
+  const text = `${conversation ? `<conversation>\n${conversation}\n</conversation>` : ""}${question ? `\n\nTargeted focus:\n${question}` : ""}`;
+  // A zero context limit with no targeted focus would otherwise send an empty
+  // user message, which several providers reject outright.
+  return (
+    text.trim() ||
+    "No conversation context is available. State that you cannot review without context."
+  );
+};
 
 /** The sole reconstructed-context boundary for outgoing Advisor requests. */
 export const advisorRequestConversation = (ctx: ExtensionContext) =>
@@ -96,6 +104,19 @@ export const renderAdvisorCallBox = (
 };
 
 const COLLAPSED_ADVICE_LINES = 12;
+// The system prompt requires this exact first line, so the match is exact too.
+const SOUND_VERDICT = /^Verdict:\s*sound$/;
+
+export const hasSoundVerdict = (advice: string) =>
+  SOUND_VERDICT.test(
+    (advice.split("\n").find((line) => line.trim()) ?? "").trim()
+  );
+
+/** The single Advisor response header shared by tool and manual renderers. */
+export const renderAdvisorResponseHeader = (sound: boolean, theme: Theme) =>
+  sound
+    ? theme.fg("accent", theme.bold("◆ ADVISOR · SOUND"))
+    : theme.fg("warning", theme.bold("◆ ADVISOR RESPONSE"));
 
 export const adviceForDisplay = (advice: string, expanded: boolean) => {
   if (!advisorCollapseResponsesRef || expanded) {
@@ -109,6 +130,11 @@ export const adviceForDisplay = (advice: string, expanded: boolean) => {
 };
 
 export const advisorInvocationGuidelines = () => {
+  if (isSimpleMode()) {
+    return [
+      "When uncertain and normal available tools cannot resolve it, call ask_advisor for a second opinion.",
+    ];
+  }
   const guidelines: string[] = [];
   if (advisorPlanGateRef) {
     guidelines.push(
@@ -141,6 +167,7 @@ export const ADVISOR_SYSTEM = [
   "You already have the relevant reconstructed conversation context. No question or other input from the Executor is needed for a general review.",
   "When no targeted focus is supplied, proactively review the task, risks, proposed direction, and validation from the context. Do not ask the Executor for a question, clarification, more input, or confirmation.",
   "The context may be truncated, so state any material uncertainty and make the best recommendation you can from what is present.",
+  "When the implementation is fully sound based on the supplied evidence and you have no material concern or recommended change, begin with exactly `Verdict: sound`. Do not use that verdict when uncertainty, a risk, or a recommendation remains.",
   "You do not act or take over planning. Answer the Executor's request directly in concise, human-readable Markdown. State uncertainty plainly and never claim verification that the supplied evidence does not show.",
 ].join(" ");
 
@@ -193,6 +220,7 @@ export const advisorUsageCost = (usage: unknown): number | undefined => {
 
 const DECISION_LINE = /^Decision\s*:\s*(proceed|revise|blocked)\s*$/i;
 const ANY_DECISION_LINE = /^Decision\s*:\s*(.*?)\s*$/i;
+const CODE_FENCE = /^(?:```|~~~)/;
 const LINE_BREAK = /\r?\n/;
 
 export const parseAutomaticDecision = (
@@ -221,8 +249,19 @@ export const parseAutomaticDecision = (
     };
   }
   const decision = match[1].toLowerCase() as GateDecision;
+  let insideFence = false;
   for (const line of lines.slice(nonEmpty + 1)) {
-    const subsequent = ANY_DECISION_LINE.exec(line.trim());
+    const trimmed = line.trim();
+    // A decision quoted inside a fenced example is illustrative, not a second
+    // decision, and must not fail the gate.
+    if (CODE_FENCE.test(trimmed)) {
+      insideFence = !insideFence;
+      continue;
+    }
+    if (insideFence) {
+      continue;
+    }
+    const subsequent = ANY_DECISION_LINE.exec(trimmed);
     if (!subsequent) {
       continue;
     }
@@ -453,7 +492,7 @@ const reserveAdvisorCall = (
   session: AdvisorSessionState,
   reservedCalls: Set<string>
 ): ToolCallEventResult | undefined => {
-  if (event.toolName !== "ask_advisor") {
+  if (event.toolName !== "ask_advisor" || isSimpleMode()) {
     return;
   }
   if (!session.canConsult(advisorMaxCallsPerSessionRef)) {
@@ -521,6 +560,7 @@ const handleAutomaticGate = async (
   session: AdvisorSessionState
 ): Promise<ToolCallEventResult | undefined> => {
   if (
+    isSimpleMode() ||
     event.toolName === "ask_advisor" ||
     !advisorAutoLoopGateRef ||
     !session.recordToolCall(
@@ -665,7 +705,8 @@ const renderFinalAdvisorResult = (
     context.state.timerId = undefined;
   }
   const details = advisorResultDetails(result);
-  const lines = [theme.fg("warning", theme.bold("◆ ADVISOR RESPONSE"))];
+  const advice = details?.text || textFrom(result.content);
+  const lines = [renderAdvisorResponseHeader(hasSoundVerdict(advice), theme)];
   if (details?.advisor) {
     lines.push(theme.fg("dim", `  ${details.advisor}`));
   }
@@ -678,13 +719,15 @@ const renderFinalAdvisorResult = (
       )
     );
   }
-  const advice =
-    details?.text ||
-    textFrom(result.content) ||
-    "(Advisor returned no advice.)";
+  const displayAdvice = advice || "(Advisor returned no advice.)";
   box.addChild(new Text(lines.join("\n"), 0, 0));
   box.addChild(
-    new Markdown(adviceForDisplay(advice, expanded), 0, 0, getMarkdownTheme())
+    new Markdown(
+      adviceForDisplay(displayAdvice, expanded),
+      0,
+      0,
+      getMarkdownTheme()
+    )
   );
 };
 
@@ -779,7 +822,9 @@ export const registerAdvisorTool = (pi: ExtensionAPI) => {
     }
     loadConfig(ctx);
     const guidelines = advisorInvocationGuidelines();
-    const budget = session.remainingCalls(advisorMaxCallsPerSessionRef);
+    const budget = isSimpleMode()
+      ? undefined
+      : session.remainingCalls(advisorMaxCallsPerSessionRef);
     if (budget !== undefined) {
       guidelines.push(
         `Advisor calls remaining this session: ${budget}.\nReserve calls for material decisions, repeated failures, or final review.`
@@ -797,7 +842,14 @@ export const registerAdvisorTool = (pi: ExtensionAPI) => {
       return;
     }
     loadConfig(ctx);
-    if (session.blocked) {
+    if (isSimpleMode()) {
+      // Simple mode does not gate, so a block recorded before it was enabled must
+      // not linger in session or Herdr state and misreport the session as blocked.
+      if (session.blocked) {
+        session.clearBlocked();
+        herdrAdvisorBlock.clear();
+      }
+    } else if (session.blocked) {
       return {
         block: true,
         reason: session.blockedReason ?? "Advisor session is blocked.",
@@ -811,7 +863,7 @@ export const registerAdvisorTool = (pi: ExtensionAPI) => {
   });
 
   pi.on("agent_settled", (_event, ctx) => {
-    if (session.blocked || !advisorSessionSummaryRef) {
+    if (isSimpleMode() || session.blocked || !advisorSessionSummaryRef) {
       return;
     }
     const summary = session.summary(advisorMaxCallsPerSessionRef);
@@ -829,7 +881,7 @@ export const registerAdvisorTool = (pi: ExtensionAPI) => {
     description:
       "Consult the on-demand Advisor model for strategic guidance. Call with an empty object for a context-aware review; add question only for a genuinely targeted focus.",
     async execute(_id, params, signal, onUpdate, ctx) {
-      if (!reservedCalls.delete(_id)) {
+      if (!(reservedCalls.delete(_id) || isSimpleMode())) {
         if (!session.canConsult(advisorMaxCallsPerSessionRef)) {
           throw new Error("Advisor call budget exhausted for this session.");
         }

package/src/ui.ts

@@ -185,6 +185,7 @@ export interface ContextPreset {
 }
 
 export interface AdvisorSettings {
+  alwaysOn?: boolean;
   autoLoopGate?: boolean;
   blockOnBlocked?: boolean;
   collapseResponses: boolean;
@@ -200,11 +201,68 @@ export interface AdvisorSettings {
   planGate: boolean;
   redactSecrets?: boolean;
   sessionSummary?: boolean;
+  simpleMode?: boolean;
   toolPolicies?: Record<string, "full" | "summary" | "exclude">;
   toolResultMaxBytes?: number;
   toolResultMaxLines?: number;
 }
 
+type AdvisorSettingsRow =
+  | "simpleMode"
+  | "alwaysOn"
+  | "context"
+  | "effort"
+  | "planGate"
+  | "failureGate"
+  | "completionGate"
+  | "collapseResponses"
+  | "customRule"
+  | "blockOnBlocked"
+  | "autoLoopGate"
+  | "loopThreshold"
+  | "maxCallsPerSession"
+  | "sessionSummary"
+  | "failureMode"
+  | "herdrIntegration"
+  | "toolResultMaxLines"
+  | "toolResultMaxBytes"
+  | "redactSecrets"
+  | "toolPolicies"
+  | "save";
+
+const ADVANCED_ROWS: AdvisorSettingsRow[] = [
+  "context",
+  "effort",
+  "planGate",
+  "failureGate",
+  "completionGate",
+  "collapseResponses",
+  "customRule",
+  "blockOnBlocked",
+  "autoLoopGate",
+  "loopThreshold",
+  "maxCallsPerSession",
+  "sessionSummary",
+  "failureMode",
+  "herdrIntegration",
+  "toolResultMaxLines",
+  "toolResultMaxBytes",
+  "redactSecrets",
+  "toolPolicies",
+];
+
+const SIMPLE_MODE_GRADIENT_INTERVAL_MS = 100;
+// #763FCD and nearby lighter/darker purple steps; white is the moving shine.
+const SIMPLE_MODE_GRADIENT_COLORS = [
+  [125, 79, 205],
+  [143, 96, 218],
+  [160, 114, 230],
+  [178, 135, 238],
+  [195, 157, 245],
+  [168, 120, 230],
+  [143, 89, 215],
+] as const;
+
 export class AdvisorSettingsSelector implements Component, Focusable {
   private selectedRow: number;
   private contextIndex: number;
@@ -215,6 +273,8 @@ export class AdvisorSettingsSelector implements Component, Focusable {
   private editingCustom: boolean;
   private editingPolicies: boolean;
   private policiesError: string | undefined;
+  private simpleModeGradientStartedAt: number | undefined;
+  private simpleModeGradientTimer: ReturnType<typeof setInterval> | undefined;
   private _focused = false;
   private readonly options: AdvisorSettingsSelectorOptions;
 
@@ -233,6 +293,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     this.editingPolicies = false;
     this.policiesError = undefined;
     this.options = options;
+    // Retain every advanced value even when Simple mode hides its controls.
     this.settings = { ...options.initial };
     this.contextIndex = Math.max(
       0,
@@ -246,6 +307,9 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         this.settings.effort || "Default (Model Default)"
       )
     );
+    if (this.settings.simpleMode) {
+      this.startSimpleModeGradient();
+    }
     this.customInput.onSubmit = (value) => {
       this.settings.customRule = value.trim() || undefined;
       this.editingCustom = false;
@@ -289,6 +353,25 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     this.options.tui.requestRender();
   }
 
+  /** Called by TUI teardown when it supports component disposal. */
+  dispose(): void {
+    this.stopSimpleModeGradient();
+  }
+
+  private visibleRows(): AdvisorSettingsRow[] {
+    return this.settings.simpleMode
+      ? ["context", "simpleMode", "alwaysOn", "save"]
+      : ["simpleMode", "alwaysOn", ...ADVANCED_ROWS, "save"];
+  }
+
+  private selectedRowId(): AdvisorSettingsRow {
+    return this.visibleRows()[this.selectedRow] ?? "simpleMode";
+  }
+
+  private focusRow(rowId: AdvisorSettingsRow): void {
+    this.selectedRow = Math.max(0, this.visibleRows().indexOf(rowId));
+  }
+
   private currentContext(): ContextPreset {
     const preset = this.options.presets.find(
       (item) => item.value === this.settings.contextMaxChars
@@ -301,125 +384,167 @@ export class AdvisorSettingsSelector implements Component, Focusable {
       }
     );
   }
+
   private currentEffort() {
     return this.settings.effort || "Default (Model Default)";
   }
-  private row(label: string, value: string, index: number) {
+
+  private row(label: string, value: string, rowId: AdvisorSettingsRow): string {
     const { theme } = this.options;
-    const prefix = index === this.selectedRow ? theme.fg("accent", "›") : " ";
+    const selected = rowId === this.selectedRowId();
+    const prefix = selected ? theme.fg("accent", "›") : " ";
     const text = `${prefix} ${label.padEnd(28)} ${value}`;
-    return index === this.selectedRow
+    if (
+      rowId === "simpleMode" &&
+      this.settings.simpleMode &&
+      this.simpleModeGradientStartedAt !== undefined
+    ) {
+      return `${prefix} ${this.rainbowGradient(label)}${" ".repeat(Math.max(0, 28 - label.length))} ${value}`;
+    }
+    return selected
       ? theme.fg("accent", theme.bold(text))
       : theme.fg("text", text);
   }
 
-  private policyInputRows(width: number): string[] {
-    if (!this.editingPolicies) {
-      return [];
-    }
-    const rows = [
-      `    ${this.policiesInput.render(Math.max(10, width - 6))[0] || ""}`,
-    ];
-    if (this.policiesError) {
-      rows.push(`    ${this.options.theme.fg("error", this.policiesError)}`);
-    }
-    return rows;
+  private rainbowGradient(text: string): string {
+    const frame = Math.floor(
+      (Date.now() - (this.simpleModeGradientStartedAt ?? 0)) /
+        SIMPLE_MODE_GRADIENT_INTERVAL_MS
+    );
+    const shinePosition = frame % (text.length * 2);
+    return [...text]
+      .map((character, index) => {
+        const [baseRed, baseGreen, baseBlue] =
+          SIMPLE_MODE_GRADIENT_COLORS[
+            index % SIMPLE_MODE_GRADIENT_COLORS.length
+          ];
+        const distance = Math.abs(index - shinePosition);
+        let brightness = 0;
+        if (distance === 0) {
+          brightness = 0.7;
+        } else if (distance === 1) {
+          brightness = 0.35;
+        }
+        const red = Math.round(baseRed + (255 - baseRed) * brightness);
+        const green = Math.round(baseGreen + (255 - baseGreen) * brightness);
+        const blue = Math.round(baseBlue + (255 - baseBlue) * brightness);
+        return `\x1b[38;2;${red};${green};${blue}m${character}`;
+      })
+      .join("")
+      .concat("\x1b[0m");
   }
 
-  render(width: number): string[] {
-    const { theme, presets } = this.options;
-    const trackWidth = Math.max(24, Math.min(60, width - 4));
-    const positions = presets.map((_, index) =>
-      Math.round((index * (trackWidth - 1)) / Math.max(1, presets.length - 1))
-    );
-    const track = Array.from({ length: trackWidth }, () => "─");
-    track[positions[this.contextIndex]] = "▲";
-    const labels = Array.from({ length: trackWidth }, () => " ");
-    for (let index = 0; index < presets.length; index += 1) {
-      const { label } = presets[index];
-      const start = Math.max(
-        0,
-        Math.min(
-          trackWidth - label.length,
-          positions[index] - Math.floor(label.length / 2)
-        )
-      );
-      for (let char = 0; char < label.length; char += 1) {
-        labels[start + char] = label[char];
-      }
+  private startSimpleModeGradient(): void {
+    this.stopSimpleModeGradient();
+    this.simpleModeGradientStartedAt = Date.now();
+    this.simpleModeGradientTimer = setInterval(() => {
+      this.options.tui.requestRender();
+    }, SIMPLE_MODE_GRADIENT_INTERVAL_MS);
+    this.simpleModeGradientTimer.unref?.();
+  }
+
+  private stopSimpleModeGradient(): void {
+    if (this.simpleModeGradientTimer) {
+      clearInterval(this.simpleModeGradientTimer);
+      this.simpleModeGradientTimer = undefined;
     }
-    const heading = `Recent history${" ".repeat(Math.max(1, trackWidth - "Recent history".length - "Full branch".length))}Full branch`;
+    this.simpleModeGradientStartedAt = undefined;
+  }
+
+  private save(): void {
+    this.stopSimpleModeGradient();
+    this.options.onSave({
+      ...this.settings,
+      contextMaxChars: this.currentContext().value,
+      effort: this.currentEffort(),
+    });
+  }
+
+  private cancel(): void {
+    this.stopSimpleModeGradient();
+    this.options.onCancel();
+  }
+
+  private advancedRows(width: number): string[] {
     const onOff = (value: boolean) => (value ? "On" : "Off");
     const rows = [
-      this.row("Context window", this.currentContext().label, 0),
-      this.row("Advisor reasoning", this.currentEffort(), 1),
-      this.row("Plan gate", onOff(this.settings.planGate), 2),
-      this.row("Failure gate", onOff(this.settings.failureGate), 3),
-      this.row("Completion gate", onOff(this.settings.completionGate), 4),
+      this.row("Context window", this.currentContext().label, "context"),
+      this.row("Advisor reasoning", this.currentEffort(), "effort"),
+      this.row("Plan gate", onOff(this.settings.planGate), "planGate"),
+      this.row("Failure gate", onOff(this.settings.failureGate), "failureGate"),
+      this.row(
+        "Completion gate",
+        onOff(this.settings.completionGate),
+        "completionGate"
+      ),
       this.row(
         "Collapse long responses",
         onOff(this.settings.collapseResponses),
-        5
+        "collapseResponses"
+      ),
+      this.row(
+        "Custom invocation",
+        this.settings.customRule || "None",
+        "customRule"
       ),
-      this.row("Custom invocation", this.settings.customRule || "None", 6),
       this.row(
         "Block on critical advice",
         onOff(this.settings.blockOnBlocked ?? true),
-        7
+        "blockOnBlocked"
       ),
       this.row(
         "Automatic loop gate",
         onOff(this.settings.autoLoopGate ?? true),
-        8
+        "autoLoopGate"
       ),
       this.row(
         "Loop threshold",
         `After ${this.settings.loopThreshold ?? 3} repeats`,
-        9
+        "loopThreshold"
       ),
       this.row(
         "Max Advisor calls/session",
         this.settings.maxCallsPerSession === undefined
           ? "∞"
           : String(this.settings.maxCallsPerSession),
-        10
+        "maxCallsPerSession"
       ),
       this.row(
         "Session Advisor Summary",
-        onOff(this.settings.sessionSummary ?? true),
-        11
+        onOff(this.settings.sessionSummary ?? false),
+        "sessionSummary"
       ),
       this.row(
         "Gate failure mode",
         this.settings.failureMode ?? "block-session",
-        12
+        "failureMode"
       ),
       this.row(
         "Herdr integration",
         onOff(this.settings.herdrIntegration ?? true),
-        13
+        "herdrIntegration"
       ),
       this.row(
         "Tool result lines",
         String(this.settings.toolResultMaxLines ?? 2000),
-        14
+        "toolResultMaxLines"
       ),
       this.row(
         "Tool result bytes",
         String(this.settings.toolResultMaxBytes ?? 50 * 1024),
-        15
+        "toolResultMaxBytes"
       ),
       this.row(
         "Redact common secrets",
         onOff(this.settings.redactSecrets ?? false),
-        16
+        "redactSecrets"
       ),
       this.row(
         "Tool disclosure policies",
         Object.keys(this.settings.toolPolicies ?? {}).length
           ? "Exact names configured"
           : "All tools: full",
-        17
+        "toolPolicies"
       ),
     ];
     if (this.editingCustom) {
@@ -427,19 +552,96 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         `    ${this.customInput.render(Math.max(10, width - 6))[0] || ""}`
       );
     }
-    rows.push(...this.policyInputRows(width));
-    rows.push(this.row("Save changes", "", 18));
-    return [
-      theme.fg("accent", theme.bold("  Advisor settings")),
-      "",
-      `  ${theme.fg("muted", heading)}`,
-      `  ${theme.fg("muted", track.join(""))}`,
-      `  ${theme.fg("text", labels.join(""))}`,
-      "",
-      ...rows.map((line) => `  ${line}`),
-      "",
-      `  ${theme.fg("muted", "↑/↓ select · ←/→ adjust · Enter edits or saves · Esc cancels")}`,
-    ].map((line) => truncateToWidth(line, width));
+    if (this.editingPolicies) {
+      rows.push(
+        `    ${this.policiesInput.render(Math.max(10, width - 6))[0] || ""}`
+      );
+      if (this.policiesError) {
+        rows.push(`    ${this.options.theme.fg("error", this.policiesError)}`);
+      }
+    }
+    rows.push(this.row("Save changes", "", "save"));
+    return rows;
+  }
+
+  render(width: number): string[] {
+    const { theme, presets } = this.options;
+    const simpleMode = this.settings.simpleMode ?? false;
+    const modeRows = [
+      this.row("Simple mode", simpleMode ? "On" : "Off", "simpleMode"),
+      this.row("Always on", this.settings.alwaysOn ? "On" : "Off", "alwaysOn"),
+    ];
+    const lines = [theme.fg("accent", theme.bold("  Advisor settings")), ""];
+    if (simpleMode) {
+      const trackWidth = Math.max(24, Math.min(60, width - 4));
+      const positions = presets.map((_, index) =>
+        Math.round((index * (trackWidth - 1)) / Math.max(1, presets.length - 1))
+      );
+      const track = Array.from({ length: trackWidth }, () => "─");
+      track[positions[this.contextIndex]] = "▲";
+      const labels = Array.from({ length: trackWidth }, () => " ");
+      for (let index = 0; index < presets.length; index += 1) {
+        const { label } = presets[index];
+        const start = Math.max(
+          0,
+          Math.min(
+            trackWidth - label.length,
+            positions[index] - Math.floor(label.length / 2)
+          )
+        );
+        for (let char = 0; char < label.length; char += 1) {
+          labels[start + char] = label[char];
+        }
+      }
+      lines.push(
+        `  ${this.row("Context window", this.currentContext().label, "context")}`
+      );
+      lines.push(`  ${theme.fg("muted", "Recent history")}`);
+      lines.push(`  ${theme.fg("muted", track.join(""))}`);
+      lines.push(`  ${theme.fg("text", labels.join(""))}`);
+      lines.push("");
+      lines.push(...modeRows.map((line) => `  ${line}`));
+      lines.push(`  ${this.row("Save changes", "", "save")}`);
+      lines.push("");
+      lines.push(
+        `  ${theme.fg("muted", "↑/↓ select · ←/→ adjust · Enter saves · Esc cancels")}`
+      );
+      return lines.map((line) => truncateToWidth(line, width));
+    }
+
+    const trackWidth = Math.max(24, Math.min(60, width - 4));
+    const positions = presets.map((_, index) =>
+      Math.round((index * (trackWidth - 1)) / Math.max(1, presets.length - 1))
+    );
+    const track = Array.from({ length: trackWidth }, () => "─");
+    track[positions[this.contextIndex]] = "▲";
+    const labels = Array.from({ length: trackWidth }, () => " ");
+    for (let index = 0; index < presets.length; index += 1) {
+      const { label } = presets[index];
+      const start = Math.max(
+        0,
+        Math.min(
+          trackWidth - label.length,
+          positions[index] - Math.floor(label.length / 2)
+        )
+      );
+      for (let char = 0; char < label.length; char += 1) {
+        labels[start + char] = label[char];
+      }
+    }
+    const heading = `Recent history${" ".repeat(Math.max(1, trackWidth - "Recent history".length - "Full branch".length))}Full branch`;
+    lines.push(`  ${theme.fg("muted", heading)}`);
+    lines.push(`  ${theme.fg("muted", track.join(""))}`);
+    lines.push(`  ${theme.fg("text", labels.join(""))}`);
+    lines.push("");
+    lines.push(
+      ...[...modeRows, ...this.advancedRows(width)].map((line) => `  ${line}`)
+    );
+    lines.push("");
+    lines.push(
+      `  ${theme.fg("muted", "↑/↓ select · ←/→ adjust · Enter edits or saves · Esc cancels")}`
+    );
+    return lines.map((line) => truncateToWidth(line, width));
   }
 
   handleInput(keyData: string): void {
@@ -455,20 +657,24 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     if (matchesKey(keyData, Key.up)) {
       this.selectedRow = Math.max(0, this.selectedRow - 1);
     } else if (matchesKey(keyData, Key.down)) {
-      this.selectedRow = Math.min(18, this.selectedRow + 1);
+      this.selectedRow = Math.min(
+        this.visibleRows().length - 1,
+        this.selectedRow + 1
+      );
     } else if (matchesKey(keyData, Key.left)) {
       this.adjust(-1);
     } else if (matchesKey(keyData, Key.right)) {
       this.adjust(1);
     } else if (matchesKey(keyData, Key.enter)) {
-      if (this.selectedRow === 6) {
+      const row = this.selectedRowId();
+      if (row === "customRule") {
         this.editingCustom = true;
         this.customInput.setValue(this.settings.customRule || "");
         this.customInput.focused = this.focused;
         tui.requestRender();
         return;
       }
-      if (this.selectedRow === 17) {
+      if (row === "toolPolicies") {
         this.editingPolicies = true;
         this.policiesError = undefined;
         this.policiesInput.setValue(
@@ -478,17 +684,13 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         tui.requestRender();
         return;
       }
-      if (this.selectedRow === 18) {
-        this.options.onSave({
-          ...this.settings,
-          contextMaxChars: this.currentContext().value,
-          effort: this.currentEffort(),
-        });
+      if (row === "save") {
+        this.save();
         return;
       }
       this.adjust(1);
     } else if (matchesKey(keyData, Key.escape)) {
-      this.options.onCancel();
+      this.cancel();
       return;
     } else {
       return;
@@ -496,9 +698,23 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     tui.requestRender();
   }
 
-  private adjust(direction: number) {
-    switch (this.selectedRow) {
-      case 0:
+  private adjust(direction: number): void {
+    switch (this.selectedRowId()) {
+      case "simpleMode":
+        this.settings.simpleMode = !(this.settings.simpleMode ?? false);
+        if (this.settings.simpleMode) {
+          this.startSimpleModeGradient();
+        } else {
+          this.stopSimpleModeGradient();
+        }
+        // The visible row set changes with the mode, so keep the cursor on the
+        // row the user is actually operating rather than on its old index.
+        this.focusRow("simpleMode");
+        break;
+      case "alwaysOn":
+        this.settings.alwaysOn = !(this.settings.alwaysOn ?? false);
+        break;
+      case "context":
         this.contextIndex = Math.max(
           0,
           Math.min(
@@ -509,7 +725,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         this.settings.contextMaxChars =
           this.options.presets[this.contextIndex].value;
         break;
-      case 1:
+      case "effort":
         this.effortIndex = Math.max(
           0,
           Math.min(
@@ -519,31 +735,31 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         );
         this.settings.effort = this.options.effortLevels[this.effortIndex];
         break;
-      case 2:
+      case "planGate":
         this.settings.planGate = !this.settings.planGate;
         break;
-      case 3:
+      case "failureGate":
         this.settings.failureGate = !this.settings.failureGate;
         break;
-      case 4:
+      case "completionGate":
         this.settings.completionGate = !this.settings.completionGate;
         break;
-      case 5:
+      case "collapseResponses":
         this.settings.collapseResponses = !this.settings.collapseResponses;
         break;
-      case 7:
+      case "blockOnBlocked":
         this.settings.blockOnBlocked = !(this.settings.blockOnBlocked ?? true);
         break;
-      case 8:
+      case "autoLoopGate":
         this.settings.autoLoopGate = !(this.settings.autoLoopGate ?? true);
         break;
-      case 9:
+      case "loopThreshold":
         this.settings.loopThreshold = Math.max(
           2,
           (this.settings.loopThreshold ?? 3) + direction
         );
         break;
-      case 10: {
+      case "maxCallsPerSession": {
         const values = [undefined, 0, 1, 2, 3, 5, 10, 25, 50];
         const index = Math.max(
           0,
@@ -553,10 +769,10 @@ export class AdvisorSettingsSelector implements Component, Focusable {
           values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
-      case 11:
-        this.settings.sessionSummary = !(this.settings.sessionSummary ?? true);
+      case "sessionSummary":
+        this.settings.sessionSummary = !(this.settings.sessionSummary ?? false);
         break;
-      case 12: {
+      case "failureMode": {
         const modes: AdvisorSettings["failureMode"][] = [
           "block-session",
           "block-tool",
@@ -570,15 +786,15 @@ export class AdvisorSettingsSelector implements Component, Focusable {
           modes[Math.max(0, Math.min(modes.length - 1, index + direction))];
         break;
       }
-      case 13:
+      case "herdrIntegration":
         this.settings.herdrIntegration = !(
           this.settings.herdrIntegration ?? true
         );
         break;
-      case 16:
+      case "redactSecrets":
         this.settings.redactSecrets = !(this.settings.redactSecrets ?? false);
         break;
-      case 14: {
+      case "toolResultMaxLines": {
         const values = [0, 500, 1000, 2000, 5000, 10_000];
         const index = Math.max(
           0,
@@ -588,7 +804,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
           values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
-      case 15: {
+      case "toolResultMaxBytes": {
         const values = [0, 10 * 1024, 50 * 1024, 100 * 1024, 500 * 1024];
         const index = Math.max(
           0,