pi-advisor-flow 0.3.6 → 0.5.0

package/src/commands.ts

@@ -2,16 +2,17 @@ import {
   type ExtensionAPI,
   type ExtensionContext,
   getMarkdownTheme,
+  type Theme,
 } from "@earendil-works/pi-coding-agent";
-import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import { Box, type Component, Markdown, Text } from "@earendil-works/pi-tui";
 import {
   advisorEffortRef,
-  advisorMaxCallsPerSessionRef,
   advisorRef,
   alwaysOnRef,
   contextMaxCharsRef,
   executorEffortRef,
   executorRef,
+  getAdvisorMaxCallsPerSession,
   getAdvisorSettings,
   isSimpleMode,
   loadConfig,
@@ -46,13 +47,15 @@ import {
   setContextMaxCharsRef,
   setExecutorEffortRef,
   setExecutorRef,
+  setShowUsageDetailsRef,
+  setShowUsageFooterRef,
   setSimpleModeRef,
   splitRef,
 } from "./config.js";
+import type { GitContextLevel } from "./git.js";
 import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "./herdr.js";
 import type { ScoutLifecycleEvent } from "./scout.js";
 import type { AdvisorSessionState } from "./session-state.js";
-import type { BenchmarkTelemetry } from "./telemetry.js";
 import {
   adviceForDisplay,
   appendScoutLifecycleEntry,
@@ -61,15 +64,25 @@ import {
   hasSoundVerdict,
   renderAdvisorCallBox,
   renderAdvisorResponseHeader,
+  renderScoutDetails,
   resolveAdvisorRequest,
   ScoutStatusManager,
+  type ScoutToolDetails,
+  SPINNER_FRAMES,
 } from "./tools.js";
 import {
   type AdvisorSettings,
   AdvisorSettingsSelector,
   type ContextPreset,
+  ManualAdvisorDialog,
+  type ManualAdvisorRequest,
   SearchableModelSelector,
 } from "./ui.js";
+import {
+  advisorUsageCost,
+  formatAdvisorUsage,
+  snapshotAdvisorUsage,
+} from "./usage.js";
 
 const DEFAULT_EFFORT_LEVEL = "Default (Model Default)";
 const SELECTED_PREFIX = "✓ ";
@@ -139,12 +152,14 @@ type ManualConsult = (
   question?: string,
   signal?: AbortSignal,
   onChunk?: (thinking: string, text: string) => void,
-  onScout?: (event: ScoutLifecycleEvent) => void
+  onScout?: (event: ScoutLifecycleEvent) => void,
+  gitContext?: GitContextLevel
 ) => Promise<{
   markdown: string;
   thinkingText: string;
   draftBytes?: number;
   preferenceBytes?: number;
+  usage?: unknown;
 }>;
 type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
 
@@ -158,54 +173,215 @@ const notify = (
   }
 };
 
+type ManualAdvisorProgressPhase =
+  | "preparing"
+  | "active"
+  | "complete"
+  | "cancelled"
+  | "error";
+interface ManualAdvisorProgressState {
+  phase: ManualAdvisorProgressPhase;
+  scout?: ScoutToolDetails;
+  text?: string;
+  thinking?: string;
+}
+
+class ManualAdvisorProgressComponent implements Component {
+  private readonly question: string | undefined;
+  private readonly state: ManualAdvisorProgressState;
+  private readonly expanded: boolean;
+  private readonly theme: Theme;
+
+  constructor(
+    question: string | undefined,
+    state: ManualAdvisorProgressState,
+    expanded: boolean,
+    theme: Theme
+  ) {
+    this.question = question;
+    this.state = state;
+    this.expanded = expanded;
+    this.theme = theme;
+  }
+
+  render(width: number): string[] {
+    const box = renderAdvisorCallBox(this.question, this.theme);
+    if (this.state.phase === "complete" || this.state.phase === "cancelled") {
+      return box.render(width);
+    }
+
+    const { scout } = this.state;
+    const scoutActive =
+      scout?.status === "calling" || scout?.status === "streaming";
+    if (scoutActive) {
+      renderScoutDetails(box, scout, this.expanded, this.theme);
+      return box.render(width);
+    }
+    if (scout?.status === "cancelled") {
+      return box.render(width);
+    }
+    if (this.state.phase === "error") {
+      box.addChild(
+        new Text(
+          this.theme.fg("error", this.theme.bold("◆ ADVISOR · FAILED")),
+          0,
+          0
+        )
+      );
+      return box.render(width);
+    }
+
+    const frame =
+      SPINNER_FRAMES[Math.floor(Date.now() / 80) % SPINNER_FRAMES.length];
+    let status = "Working…";
+    if (this.state.phase === "preparing") {
+      status = "Preparing…";
+    } else if (this.state.text?.trim()) {
+      status = "Responding…";
+    }
+    box.addChild(
+      new Text(
+        `${this.theme.fg("warning", this.theme.bold(`◆ ADVISOR ${frame}`))} ${this.theme.fg("dim", `· ${status}`)}`,
+        0,
+        0
+      )
+    );
+    if (this.state.thinking) {
+      box.addChild(
+        new Text(
+          this.theme.fg(
+            "thinkingText",
+            `  💭 ${this.state.thinking.replace(/\n/g, " ").slice(-200)}`
+          ),
+          0,
+          0
+        )
+      );
+    }
+    if (this.state.text) {
+      box.addChild(
+        new Markdown(
+          adviceForDisplay(this.state.text, this.expanded),
+          0,
+          0,
+          getMarkdownTheme()
+        )
+      );
+    }
+    return box.render(width);
+  }
+
+  invalidate(): void {
+    // The live progress state is read during each render.
+  }
+}
+
 const findConfiguredModel = (ctx: ExtensionContext, ref: string) => {
   const [provider, modelId] = splitRef(ref);
   return ctx.modelRegistry.find(provider, modelId);
 };
 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
+const applyAdvisorSettings = (settings: AdvisorSettings) => {
+  setAdvisorEffortRef(
+    settings.effort === "Default (Model Default)" ? undefined : settings.effort
+  );
+  setContextMaxCharsRef(settings.contextMaxChars);
+  setAdvisorPlanGateRef(settings.planGate);
+  setAdvisorFailureGateRef(settings.failureGate);
+  setAdvisorCompletionGateRef(settings.completionGate);
+  setAdvisorCollapseResponsesRef(settings.collapseResponses);
+  setAdvisorCustomInvocationRef(settings.customRule);
+  setAdvisorBlockOnBlockedRef(settings.blockOnBlocked ?? true);
+  setAdvisorAutoLoopGateRef(settings.autoLoopGate ?? true);
+  setAdvisorLoopThresholdRef(settings.loopThreshold ?? 3);
+  setAdvisorMaxCallsPerSessionRef(settings.maxCallsPerSession);
+  setAdvisorSessionSummaryRef(settings.sessionSummary ?? false);
+  setAdvisorScoutEnabledRef(settings.scoutEnabled ?? false);
+  setShowUsageDetailsRef(settings.showUsageDetails ?? true);
+  setShowUsageFooterRef(settings.showUsageFooter ?? false);
+  setSimpleModeRef(settings.simpleMode ?? false);
+  setAlwaysOnRef(settings.alwaysOn ?? false);
+  setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
+  setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
+  setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
+  setAdvisorToolResultMaxBytesRef(settings.toolResultMaxBytes ?? 50 * 1024);
+  setAdvisorRedactSecretsRef(settings.redactSecrets ?? false);
+  setAdvisorGitContextRef(settings.gitContext ?? "summary");
+  setAdvisorGitContextMaxCharsRef(settings.gitContextMaxChars ?? 20_000);
+  setAdvisorToolPoliciesRef(settings.toolPolicies ?? {});
+  setAdvisorTrackedFileContentRef(settings.trackedFileContent ?? false);
+  setAdvisorUntrackedContentRef(settings.untrackedContent ?? false);
+  setAdvisorOutcomeLoggingRef(settings.outcomeLogging ?? false);
+};
+
+const saveAdvisorSettings = (
+  ctx: ExtensionContext,
+  settings: AdvisorSettings
+) => {
+  applyAdvisorSettings(settings);
+  saveConfig(ctx);
+  saveGlobalOutcomeLogging(settings.outcomeLogging ?? false);
+};
+
 export const registerCommands = (
   pi: ExtensionAPI,
   dependencies: {
     consult?: ManualConsult;
     sessionState?: AdvisorSessionState;
     statusManager?: ScoutStatusManager;
-    telemetry?: BenchmarkTelemetry;
   } = {}
 ) => {
   const advisorSessionState =
     dependencies.sessionState ?? defaultAdvisorSessionState;
-  const scoutStatus = dependencies.statusManager ?? new ScoutStatusManager();
+  const scoutStatus =
+    dependencies.statusManager ?? new ScoutStatusManager(false);
   const flowEnabled = () => pi.getActiveTools().includes("ask_advisor");
   const requestAdvisor =
     dependencies.consult ??
-    ((ctx, question, signal, onChunk, onScout) =>
+    ((ctx, question, signal, onChunk, onScout, gitContext) =>
       consultAdvisor(
         ctx,
         question,
         signal,
         onChunk,
         "manual",
-        undefined,
+        gitContext,
         undefined,
         undefined,
         undefined,
         onScout,
-        undefined,
-        dependencies.telemetry
+        undefined
       ));
   const manualConsultations = new Map<AbortController, symbol>();
-  const setManualStatus = (
-    ctx: ExtensionContext,
-    controller: AbortController,
-    token: symbol,
-    status: string | undefined
-  ) => {
-    if (
-      ctx.hasUI &&
-      manualConsultations.get(controller) === token &&
-      !controller.signal.aborted
-    ) {
-      ctx.ui.setStatus("advisor-manual", status);
+  const manualProgressTimers = new Map<
+    AbortController,
+    ReturnType<typeof setInterval>
+  >();
+  const manualProgress = new Map<string, ManualAdvisorProgressState>();
+  let manualProgressSequence = 0;
+  const updateAdvisorUsageStatus = (ctx: ExtensionContext) => {
+    if (ctx.hasUI) {
+      ctx.ui.setStatus(
+        "advisor-usage",
+        getAdvisorSettings().showUsageFooter
+          ? advisorSessionState.usageStatus()
+          : undefined
+      );
+    }
+  };
+  const reportManualBudgetExhausted = (ctx: ExtensionContext) => {
+    const message = "Advisor call budget exhausted for this session.";
+    notify(ctx, message, "warning");
+    notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
+  };
+
+  // A status update with an undefined value is an invisible render pulse. The
+  // transcript owns manual progress now, so no consultation text is kept in the
+  // footer while this pulse still drives the live spinner.
+  const requestManualRender = (ctx: ExtensionContext) => {
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("advisor-manual", undefined);
     }
   };
 
@@ -213,10 +389,26 @@ export const registerCommands = (
     ctx: ExtensionContext,
     question: string | undefined,
     controller: AbortController,
-    scoutStatusToken: symbol
+    scoutStatusToken: symbol,
+    progress: ManualAdvisorProgressState,
+    gitContext?: GitContextLevel
   ) => {
     herdrAdvisorActivity.start();
-    setManualStatus(ctx, controller, scoutStatusToken, "Advisor preparing…");
+    progress.phase = "preparing";
+    requestManualRender(ctx);
+    if (ctx.hasUI) {
+      const timer = setInterval(() => {
+        if (
+          controller.signal.aborted ||
+          manualConsultations.get(controller) !== scoutStatusToken
+        ) {
+          clearInterval(timer);
+          return;
+        }
+        requestManualRender(ctx);
+      }, 80);
+      manualProgressTimers.set(controller, timer);
+    }
     let scoutDetails: Parameters<typeof appendScoutLifecycleEntry>[2];
     return requestAdvisor(
       ctx,
@@ -226,52 +418,47 @@ export const registerCommands = (
         if (controller.signal.aborted) {
           return;
         }
-        let status = "Advisor working…";
-        if (thinking.trim()) {
-          status = "Advisor thinking…";
-        }
-        if (text.trim()) {
-          status = "Advisor responding…";
-        }
-        setManualStatus(ctx, controller, scoutStatusToken, status);
+        progress.phase = "active";
+        progress.thinking = thinking;
+        progress.text = text;
+        requestManualRender(ctx);
       },
       (event) => {
         if (!controller.signal.aborted) {
           scoutStatus.update(ctx, scoutStatusToken, event);
-          if (event.type === "call" || event.type === "chunk") {
-            setManualStatus(
-              ctx,
-              controller,
-              scoutStatusToken,
-              "Advisor Scout curating…"
-            );
-          } else if (event.type === "success" || event.type === "fallback") {
-            setManualStatus(
-              ctx,
-              controller,
-              scoutStatusToken,
-              "Advisor working…"
-            );
-          }
           scoutDetails = appendScoutLifecycleEntry(pi, event, scoutDetails);
+          progress.scout = scoutDetails;
+          progress.phase = "active";
+          requestManualRender(ctx);
         }
-      }
+      },
+      gitContext
     )
-      .then(({ markdown }) => {
+      .then(({ markdown, usage }) => {
         if (controller.signal.aborted) {
           return;
         }
+        progress.phase = "complete";
         advisorSessionState.recordInvocation({
+          cost: advisorUsageCost(usage),
           executionEffect: "continued",
           kind: "markdown",
           model: advisorRef,
           trigger: "manual",
+          usage,
         });
+        updateAdvisorUsageStatus(ctx);
+        const normalizedUsage = snapshotAdvisorUsage(usage);
         pi.sendMessage(
           {
             content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${markdown}`,
             customType: "advisor-manual-result",
-            details: { advisor: advisorRef, question, text: markdown },
+            details: {
+              advisor: advisorRef,
+              question,
+              text: markdown,
+              ...(normalizedUsage ? { usage: normalizedUsage } : {}),
+            },
             display: true,
           },
           {
@@ -286,6 +473,7 @@ export const registerCommands = (
         if (controller.signal.aborted) {
           return;
         }
+        progress.phase = "error";
         const message = error instanceof Error ? error.message : String(error);
         advisorSessionState.recordInvocation({
           executionEffect: "continued",
@@ -294,6 +482,7 @@ export const registerCommands = (
           model: advisorRef,
           trigger: "manual",
         });
+        updateAdvisorUsageStatus(ctx);
         pi.sendMessage(
           {
             content: `Manual Advisor consultation failed: ${message}`,
@@ -310,12 +499,15 @@ export const registerCommands = (
         notifyHerdrAdvisorFailure("Advisor consultation failed", message);
       })
       .finally(() => {
-        if (
-          ctx.hasUI &&
-          manualConsultations.get(controller) === scoutStatusToken
-        ) {
-          ctx.ui.setStatus("advisor-manual", undefined);
+        if (controller.signal.aborted) {
+          progress.phase = "cancelled";
+        }
+        const timer = manualProgressTimers.get(controller);
+        if (timer) {
+          clearInterval(timer);
+          manualProgressTimers.delete(controller);
         }
+        requestManualRender(ctx);
         scoutStatus.release(ctx, scoutStatusToken);
         manualConsultations.delete(controller);
         herdrAdvisorActivity.finish();
@@ -414,9 +606,20 @@ export const registerCommands = (
 
   pi.registerEntryRenderer?.(
     "advisor-manual-call",
-    (entry, _options, theme) => {
-      const { question } = (entry.data ?? {}) as { question?: string };
-      return renderAdvisorCallBox(question, theme);
+    (entry, { expanded }, theme) => {
+      const { progressId, question } = (entry.data ?? {}) as {
+        progressId?: string;
+        question?: string;
+      };
+      const progress = progressId ? manualProgress.get(progressId) : undefined;
+      return progress
+        ? new ManualAdvisorProgressComponent(
+            question,
+            progress,
+            Boolean(expanded),
+            theme
+          )
+        : renderAdvisorCallBox(question, theme);
     }
   );
 
@@ -424,7 +627,7 @@ export const registerCommands = (
     "advisor-manual-result",
     (message, { expanded }, theme) => {
       const details = message.details as
-        | { advisor?: string; text?: string }
+        | { advisor?: string; text?: string; usage?: unknown }
         | undefined;
       const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
       const advice =
@@ -443,6 +646,12 @@ export const registerCommands = (
       if (details?.advisor) {
         box.addChild(new Text(theme.fg("dim", `  ${details.advisor}`), 0, 0));
       }
+      if (getAdvisorSettings().showUsageDetails) {
+        const usage = formatAdvisorUsage(details?.usage);
+        if (usage) {
+          box.addChild(new Text(theme.fg("dim", `  Usage: ${usage}`), 0, 0));
+        }
+      }
       box.addChild(
         new Markdown(
           adviceForDisplay(advice, expanded),
@@ -485,39 +694,88 @@ export const registerCommands = (
 
   pi.on("session_shutdown", (_event, ctx) => {
     if (ctx.hasUI) {
-      ctx.ui.setStatus("advisor-manual", undefined);
+      ctx.ui.setStatus("advisor-usage", undefined);
     }
     for (const [controller, token] of manualConsultations) {
       controller.abort();
+      const timer = manualProgressTimers.get(controller);
+      if (timer) {
+        clearInterval(timer);
+        manualProgressTimers.delete(controller);
+      }
       scoutStatus.release(ctx, token);
     }
     scoutStatus.clear(ctx);
     manualConsultations.clear();
+    manualProgressTimers.clear();
+    manualProgress.clear();
     herdrAdvisorActivity.clear();
   });
 
   pi.registerCommand("advisor-manual", {
     description:
       "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
-    handler: (args, ctx) => {
+    handler: async (args, ctx) => {
       if (!loadCommandConfig(ctx)) {
-        return Promise.resolve();
+        return;
       }
       if (
         !(
           isSimpleMode() ||
-          advisorSessionState.canConsult(advisorMaxCallsPerSessionRef)
+          advisorSessionState.canConsult(getAdvisorMaxCallsPerSession())
         )
       ) {
-        const message = "Advisor call budget exhausted for this session.";
-        notify(ctx, message, "warning");
-        notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
-        return Promise.resolve();
+        reportManualBudgetExhausted(ctx);
+        return;
+      }
+
+      let gitContext: GitContextLevel | undefined;
+      let question: string | undefined;
+      if (ctx.mode === "tui") {
+        const request = await ctx.ui.custom<ManualAdvisorRequest | undefined>(
+          (tui, theme, keybindings, done) =>
+            new ManualAdvisorDialog({
+              gitContext: getAdvisorSettings().gitContext,
+              initialMessage: args,
+              keybindings,
+              onCancel: () => done(undefined),
+              onSubmit: done,
+              theme,
+              tui,
+            }),
+          {
+            overlay: true,
+            overlayOptions: {
+              anchor: "center",
+              margin: 2,
+              maxHeight: "80%",
+              minWidth: 56,
+              width: 76,
+            },
+          }
+        );
+        if (!request) {
+          return;
+        }
+        if (
+          !(
+            isSimpleMode() ||
+            advisorSessionState.canConsult(getAdvisorMaxCallsPerSession())
+          )
+        ) {
+          reportManualBudgetExhausted(ctx);
+          return;
+        }
+        const { gitContext: selectedGitContext, message } = request;
+        gitContext = selectedGitContext;
+        question = resolveAdvisorRequest(message);
+      } else {
+        question = resolveAdvisorRequest(args);
       }
+
       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.
       for (const [pending, token] of manualConsultations) {
@@ -527,11 +785,21 @@ export const registerCommands = (
       manualConsultations.clear();
       const controller = new AbortController();
       const scoutStatusToken = Symbol("manual-scout");
+      manualProgressSequence += 1;
+      const progressId = `manual-${manualProgressSequence}`;
+      const progress: ManualAdvisorProgressState = { phase: "preparing" };
+      manualProgress.set(progressId, progress);
       scoutStatus.register(scoutStatusToken);
       manualConsultations.set(controller, scoutStatusToken);
-      pi.appendEntry?.("advisor-manual-call", { question });
-      startManualConsultation(ctx, question, controller, scoutStatusToken);
-      return Promise.resolve();
+      pi.appendEntry?.("advisor-manual-call", { progressId, question });
+      startManualConsultation(
+        ctx,
+        question,
+        controller,
+        scoutStatusToken,
+        progress,
+        gitContext
+      );
     },
   });
 
@@ -616,68 +884,37 @@ export const registerCommands = (
   });
 
   pi.registerCommand("advisor-settings", {
-    description: "Configure Advisor context and reasoning effort",
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
+    description: "Configure Advisor settings",
     handler: async (_args, ctx) => {
       if (!(loadCommandConfig(ctx) && ctx.hasUI)) {
         return;
       }
 
       const initial: AdvisorSettings = getAdvisorSettings();
-      const settings = await ctx.ui.custom<AdvisorSettings | undefined>(
+      await ctx.ui.custom<void>(
         (tui, theme, _keybindings, done) =>
           new AdvisorSettingsSelector({
             effortLevels: EFFORT_LEVELS,
             initial,
-            onCancel: () => done(undefined),
-            onSave: done,
+            onCancel: () => done(),
+            onChange: (settings) => {
+              try {
+                saveAdvisorSettings(ctx, settings);
+                updateAdvisorUsageStatus(ctx);
+              } catch (error) {
+                const message =
+                  error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(
+                  `Could not save Advisor settings: ${message}`,
+                  "error"
+                );
+              }
+            },
             presets: CONTEXT_PRESETS,
             theme,
             tui,
           })
       );
-      if (!settings) {
-        return;
-      }
-
-      setAdvisorEffortRef(
-        settings.effort === "Default (Model Default)"
-          ? undefined
-          : settings.effort
-      );
-      setContextMaxCharsRef(settings.contextMaxChars);
-      setAdvisorPlanGateRef(settings.planGate);
-      setAdvisorFailureGateRef(settings.failureGate);
-      setAdvisorCompletionGateRef(settings.completionGate);
-      setAdvisorCollapseResponsesRef(settings.collapseResponses);
-      setAdvisorCustomInvocationRef(settings.customRule);
-      setAdvisorBlockOnBlockedRef(settings.blockOnBlocked ?? true);
-      setAdvisorAutoLoopGateRef(settings.autoLoopGate ?? true);
-      setAdvisorLoopThresholdRef(settings.loopThreshold ?? 3);
-      setAdvisorMaxCallsPerSessionRef(settings.maxCallsPerSession);
-      setAdvisorSessionSummaryRef(settings.sessionSummary ?? false);
-      setAdvisorScoutEnabledRef(settings.scoutEnabled ?? false);
-      setSimpleModeRef(settings.simpleMode ?? false);
-      setAlwaysOnRef(settings.alwaysOn ?? false);
-      setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
-      setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
-      setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
-      setAdvisorToolResultMaxBytesRef(settings.toolResultMaxBytes ?? 50 * 1024);
-      setAdvisorRedactSecretsRef(settings.redactSecrets ?? false);
-      setAdvisorGitContextRef(settings.gitContext ?? "summary");
-      setAdvisorGitContextMaxCharsRef(settings.gitContextMaxChars ?? 20_000);
-      setAdvisorToolPoliciesRef(settings.toolPolicies ?? {});
-      setAdvisorTrackedFileContentRef(settings.trackedFileContent ?? false);
-      setAdvisorUntrackedContentRef(settings.untrackedContent ?? false);
-      setAdvisorOutcomeLoggingRef(settings.outcomeLogging ?? false);
-      const path = saveConfig(ctx);
-      const globalPath = saveGlobalOutcomeLogging(
-        settings.outcomeLogging ?? false
-      );
-      ctx.ui.notify(
-        `Saved Advisor settings to ${path}; outcome logging globally to ${globalPath}`,
-        "info"
-      );
     },
   });