pi-advisor-flow 0.2.2 → 0.2.4

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,
@@ -14,6 +14,13 @@ 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;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES = DEFAULT_MAX_BYTES;
+export type AdvisorToolPolicy = "full" | "summary" | "exclude";
+export type AdvisorToolPolicies = Record<string, AdvisorToolPolicy>;
+export const ADVISOR_TOOL_POLICIES: AdvisorToolPolicy[] = [
+  "full",
+  "summary",
+  "exclude",
+];
 export type GateFailureMode =
   | "block-session"
   | "block-tool"
@@ -38,11 +45,15 @@ 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;
 export let advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
+export let advisorRedactSecretsRef = false;
+export let advisorToolPoliciesRef: AdvisorToolPolicies = {};
 
 export const setExecutorRef = (ref: string) => {
   executorRef = ref;
@@ -98,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 =>
@@ -119,12 +138,19 @@ export const setAdvisorToolResultMaxLinesRef = (value: number) => {
 export const setAdvisorToolResultMaxBytesRef = (value: number) => {
   advisorToolResultMaxBytesRef = value;
 };
+export const setAdvisorRedactSecretsRef = (enabled: boolean) => {
+  advisorRedactSecretsRef = enabled;
+};
+export const setAdvisorToolPoliciesRef = (policies: AdvisorToolPolicies) => {
+  advisorToolPoliciesRef = { ...policies };
+};
 
 /**
  * Returns the current live settings state. Use this at UI boundaries instead of
  * imported mutable bindings, which can be snapshotted by extension loaders.
  */
 export const getAdvisorSettings = () => ({
+  alwaysOn: alwaysOnRef,
   autoLoopGate: advisorAutoLoopGateRef,
   blockOnBlocked: advisorBlockOnBlockedRef,
   collapseResponses: advisorCollapseResponsesRef,
@@ -138,7 +164,10 @@ export const getAdvisorSettings = () => ({
   loopThreshold: advisorLoopThresholdRef,
   maxCallsPerSession: advisorMaxCallsPerSessionRef,
   planGate: advisorPlanGateRef,
+  redactSecrets: advisorRedactSecretsRef,
   sessionSummary: advisorSessionSummaryRef,
+  simpleMode: simpleModeRef,
+  toolPolicies: { ...advisorToolPoliciesRef },
   toolResultMaxBytes: advisorToolResultMaxBytesRef,
   toolResultMaxLines: advisorToolResultMaxLinesRef,
 });
@@ -168,13 +197,17 @@ export interface AdvisorConfig {
   advisorLoopThreshold?: number;
   advisorMaxCallsPerSession?: number;
   advisorPlanGate?: boolean;
+  advisorRedactSecrets?: boolean;
   advisorSessionSummary?: boolean;
+  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>([
@@ -191,8 +224,12 @@ const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
   "advisorMaxCallsPerSession",
   "advisorPlanGate",
   "advisorSessionSummary",
+  "simpleMode",
+  "alwaysOn",
   "advisorToolResultMaxBytes",
   "advisorToolResultMaxLines",
+  "advisorRedactSecrets",
+  "advisorToolPolicies",
   "contextMaxChars",
   "executor",
   "executorEffort",
@@ -206,7 +243,10 @@ const BOOLEAN_CONFIG_KEYS = [
   "advisorBlockOnBlocked",
   "advisorAutoLoopGate",
   "advisorSessionSummary",
+  "simpleMode",
+  "alwaysOn",
   "advisorHerdrIntegration",
+  "advisorRedactSecrets",
 ] as const;
 const STRING_CONFIG_KEYS = [
   "executor",
@@ -262,6 +302,20 @@ const validateBooleanValues = (config: ConfigRecord, path: string) => {
   }
 };
 
+export const isValidAdvisorToolPolicies = (
+  value: unknown
+): value is AdvisorToolPolicies => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Object.entries(value).every(
+    ([toolName, policy]) =>
+      toolName.trim().length > 0 &&
+      typeof policy === "string" &&
+      ADVISOR_TOOL_POLICIES.includes(policy as AdvisorToolPolicy)
+  );
+};
+
 const validateNumericValues = (config: ConfigRecord, path: string) => {
   const numericRules: [
     keyof AdvisorConfig,
@@ -315,6 +369,16 @@ export const validateConfig = (
   validateStringValues(config, path);
   validateBooleanValues(config, path);
   validateNumericValues(config, path);
+  if (
+    config.advisorToolPolicies !== undefined &&
+    !isValidAdvisorToolPolicies(config.advisorToolPolicies)
+  ) {
+    invalidConfigValue(
+      path,
+      "advisorToolPolicies",
+      "a JSON object with non-empty tool names and full, summary, or exclude values"
+    );
+  }
   if (
     config.gateFailureMode !== undefined &&
     !isValidGateFailureMode(config.gateFailureMode)
@@ -339,11 +403,15 @@ 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;
   advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
+  advisorRedactSecretsRef = false;
+  advisorToolPoliciesRef = {};
 };
 
 const applyOptionalConfig = <Key extends keyof AdvisorConfig>(
@@ -410,6 +478,8 @@ const applyConfig = (config: AdvisorConfig) => {
     "advisorSessionSummary",
     setAdvisorSessionSummaryRef
   );
+  applyOptionalConfig(config, "simpleMode", setSimpleModeRef);
+  applyOptionalConfig(config, "alwaysOn", setAlwaysOnRef);
   applyOptionalConfig(config, "gateFailureMode", setAdvisorFailureModeRef);
   applyOptionalConfig(
     config,
@@ -426,6 +496,12 @@ const applyConfig = (config: AdvisorConfig) => {
     "advisorToolResultMaxBytes",
     setAdvisorToolResultMaxBytesRef
   );
+  applyOptionalConfig(
+    config,
+    "advisorRedactSecrets",
+    setAdvisorRedactSecretsRef
+  );
+  applyOptionalConfig(config, "advisorToolPolicies", setAdvisorToolPoliciesRef);
 };
 
 const readConfig = (path: string): AdvisorConfig => {
@@ -438,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(
@@ -447,7 +560,7 @@ export const loadConfig = (ctx: ExtensionContext) => {
   if (!path) {
     return null;
   }
-  applyConfig(readConfig(path));
+  applyConfig(readConfigCached(path));
   return path;
 };
 
@@ -488,12 +601,17 @@ export const saveConfig = (ctx: ExtensionContext) => {
       ? {}
       : { advisorMaxCallsPerSession: advisorMaxCallsPerSessionRef }),
     advisorHerdrIntegration: advisorHerdrIntegrationRef,
+    advisorRedactSecrets: advisorRedactSecretsRef,
     advisorSessionSummary: advisorSessionSummaryRef,
+    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

@@ -1,5 +1,8 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
+  type AdvisorToolPolicies,
+  advisorRedactSecretsRef,
+  advisorToolPoliciesRef,
   advisorToolResultMaxBytesRef,
   advisorToolResultMaxLinesRef,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
@@ -33,6 +36,29 @@ export const textFrom = (content: unknown): string =>
 
 const byteLength = (value: string) => Buffer.byteLength(value, "utf8");
 
+const REDACTION_MARKER = "[REDACTED SECRET]";
+const SECRET_PATTERNS = [
+  /-----BEGIN(?: [A-Z0-9]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z0-9]+)? PRIVATE KEY-----/gi,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi,
+  /\b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s"'&,;)}\]]+)/gi,
+  /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi,
+  /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+  /\b(?:aws_secret_access_key|aws_session_token)\s*[:=]\s*[^\s"'&,;)}\]]+/gi,
+] as const;
+
+/** Redacts common credential forms locally; it is not a data-classification system. */
+export const redactSecrets = (value: string): string => {
+  let redacted = value;
+  for (const pattern of SECRET_PATTERNS) {
+    redacted = redacted.replace(pattern, (_match, scheme) =>
+      typeof scheme === "string"
+        ? `${scheme}${REDACTION_MARKER}@`
+        : REDACTION_MARKER
+    );
+  }
+  return redacted;
+};
+
 export interface ToolResultTruncation {
   content: string;
   omittedLines: number;
@@ -122,18 +148,35 @@ export const capToolResult = (
   };
 };
 
-const assistantEntry = (message: RecordValue): string | undefined => {
+const assistantEntry = (
+  message: RecordValue,
+  policies: AdvisorToolPolicies,
+  redact: boolean
+): string | undefined => {
   const parts: string[] = [];
   const text = textFrom(message.content);
   if (text) {
-    parts.push(text);
+    parts.push(redact ? redactSecrets(text) : text);
   }
   for (const part of contentParts(message.content)) {
     if (!isRecord(part) || part.type !== "toolCall") {
       continue;
     }
+    const toolName = typeof part.name === "string" ? part.name : "unknown";
+    const policy = policies[toolName] ?? "full";
+    if (policy === "exclude") {
+      parts.push(`[Tool Call: ${toolName}] (excluded by Advisor tool policy)`);
+      continue;
+    }
+    if (policy === "summary") {
+      parts.push(
+        `[Tool Call: ${toolName}] (arguments omitted by Advisor tool policy: summary)`
+      );
+      continue;
+    }
+    const argumentsText = JSON.stringify(part.arguments) ?? "undefined";
     parts.push(
-      `[Tool Call: ${String(part.name)}(${JSON.stringify(part.arguments)})]`
+      `[Tool Call: ${toolName}(${redact ? redactSecrets(argumentsText) : argumentsText})]`
     );
   }
   return parts.length > 0 ? `Executor: ${parts.join("\n")}` : undefined;
@@ -142,29 +185,47 @@ const assistantEntry = (message: RecordValue): string | undefined => {
 const toolResultEntry = (
   message: RecordValue,
   toolResultMaxLines: number,
-  toolResultMaxBytes: number
+  toolResultMaxBytes: number,
+  policies: AdvisorToolPolicies,
+  redact: boolean
 ): string => {
-  const status = message.isError ? "Error " : "";
+  const status = message.isError ? "error" : "success";
+  const toolName =
+    typeof message.toolName === "string" ? message.toolName : "unknown";
+  const policy = policies[toolName] ?? "full";
+  const source = textFrom(message.content);
+  if (policy === "exclude") {
+    return `[Tool Result for ${toolName}] (excluded by Advisor tool policy)`;
+  }
+  if (policy === "summary") {
+    const capped = capToolResult(
+      source,
+      toolResultMaxLines,
+      toolResultMaxBytes
+    );
+    return `[Tool Result for ${toolName}] (output omitted by Advisor tool policy: summary; status: ${status}; ${capped.totalLines} lines, ${capped.totalBytes} bytes; source output was${capped.truncated ? "" : " not"} truncated)`;
+  }
+  const disclosed = redact ? redactSecrets(source) : source;
   const capped = capToolResult(
-    textFrom(message.content),
+    disclosed,
     toolResultMaxLines,
     toolResultMaxBytes
   );
-  const toolName =
-    typeof message.toolName === "string" ? message.toolName : "unknown";
-  return `[Tool Result for ${toolName}] (${status}output):\n${capped.content}`;
+  return `[Tool Result for ${toolName}] (${message.isError ? "Error " : ""}output):\n${capped.content}`;
 };
 
 const conversationEntry = (
   entry: unknown,
   toolResultMaxLines: number,
-  toolResultMaxBytes: number
+  toolResultMaxBytes: number,
+  policies: AdvisorToolPolicies,
+  redact: boolean
 ): string | undefined => {
   if (!isRecord(entry)) {
     return;
   }
   if (entry.type === "compaction" && typeof entry.summary === "string") {
-    return `[System Compaction Summary]: ${entry.summary}`;
+    return `[System Compaction Summary]: ${redact ? redactSecrets(entry.summary) : entry.summary}`;
   }
   if (entry.type !== "message" || !isRecord(entry.message)) {
     return;
@@ -172,13 +233,19 @@ const conversationEntry = (
   const { message } = entry;
   if (message.role === "user") {
     const text = textFrom(message.content);
-    return text ? `User: ${text}` : undefined;
+    return text ? `User: ${redact ? redactSecrets(text) : text}` : undefined;
   }
   if (message.role === "assistant") {
-    return assistantEntry(message);
+    return assistantEntry(message, policies, redact);
   }
   if (message.role === "toolResult" || message.role === "tool") {
-    return toolResultEntry(message, toolResultMaxLines, toolResultMaxBytes);
+    return toolResultEntry(
+      message,
+      toolResultMaxLines,
+      toolResultMaxBytes,
+      policies,
+      redact
+    );
   }
 };
 
@@ -189,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;
     }
@@ -208,7 +283,9 @@ export const recentConversation = (
   ctx: ExtensionContext,
   maxChars = 15_000,
   toolResultMaxLines = advisorToolResultMaxLinesRef,
-  toolResultMaxBytes = advisorToolResultMaxBytesRef
+  toolResultMaxBytes = advisorToolResultMaxBytesRef,
+  policies = advisorToolPoliciesRef,
+  redact = advisorRedactSecretsRef
 ): string => {
   if (maxChars === 0) {
     return "";
@@ -216,7 +293,13 @@ export const recentConversation = (
   const entries = ctx.sessionManager
     .getBranch()
     .map((entry) =>
-      conversationEntry(entry, toolResultMaxLines, toolResultMaxBytes)
+      conversationEntry(
+        entry,
+        toolResultMaxLines,
+        toolResultMaxBytes,
+        policies,
+        redact
+      )
     )
     .filter((entry): entry is string => entry !== undefined);
   return selectRecentEntries(entries, maxChars);

package/src/tools.ts

@@ -30,6 +30,7 @@ import {
   advisorRef,
   advisorSessionSummaryRef,
   contextMaxCharsRef,
+  isSimpleMode,
   loadConfig,
   splitRef,
 } from "./config.js";
@@ -69,8 +70,19 @@ 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) =>
+  recentConversation(ctx, contextMaxCharsRef);
 
 export const renderAdvisorCallBox = (
   question: string | undefined,
@@ -92,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) {
@@ -105,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(
@@ -137,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(" ");
 
@@ -189,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 = (
@@ -217,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;
     }
@@ -272,7 +315,7 @@ const collectAdvisorResponse = async (
     throw new Error(`No API key for ${advisorRef}`);
   }
 
-  const conversation = recentConversation(ctx, contextMaxCharsRef);
+  const conversation = advisorRequestConversation(ctx);
   const messages: Message[] = [
     {
       content: [
@@ -449,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)) {
@@ -517,6 +560,7 @@ const handleAutomaticGate = async (
   session: AdvisorSessionState
 ): Promise<ToolCallEventResult | undefined> => {
   if (
+    isSimpleMode() ||
     event.toolName === "ask_advisor" ||
     !advisorAutoLoopGateRef ||
     !session.recordToolCall(
@@ -661,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}`));
   }
@@ -674,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()
+    )
   );
 };
 
@@ -775,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.`
@@ -793,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.",
@@ -807,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);
@@ -825,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.");
         }