pi-advisor-flow 0.7.0 → 0.8.0

package/src/commands/renderers.ts

@@ -1,6 +1,12 @@
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import type {
+  EntryRenderer,
+  MessageRenderer,
+} from "@earendil-works/pi-coding-agent";
 import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+
 import { getAdvisorSettings } from "../config/state.ts";
+import { isString } from "../content-utils.ts";
 import {
   adviceForDisplay,
   hasSoundVerdict,
@@ -11,66 +17,72 @@ import { formatAdvisorUsage } from "../usage.ts";
 import { ManualAdvisorProgressComponent } from "./manual-progress.ts";
 import type { CommandRuntime } from "./types.ts";
 
+interface ManualCallEntryDetails {
+  progressId?: string;
+  question?: string;
+}
+
+interface ManualResultDetails {
+  advisor?: string;
+  text?: string;
+  usage?: unknown;
+}
+
+const manualCallRenderer =
+  (runtime: CommandRuntime): EntryRenderer<ManualCallEntryDetails> =>
+  (entry, { expanded }, theme) => {
+    const { progressId, question } = entry.data ?? {};
+    const progress = progressId
+      ? runtime.manualProgress.get(progressId)
+      : undefined;
+    return progress
+      ? new ManualAdvisorProgressComponent(
+          question,
+          progress,
+          Boolean(expanded),
+          theme
+        )
+      : renderAdvisorCallBox(question, theme);
+  };
+
+const manualResultRenderer: MessageRenderer<ManualResultDetails> = (
+  message,
+  { expanded },
+  theme
+) => {
+  const { details } = message;
+  const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+  const advice =
+    details?.text ??
+    (isString(message.content)
+      ? 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));
+  }
+  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), 0, 0, getMarkdownTheme())
+  );
+  return box;
+};
+
 export const registerCommandRenderers = (runtime: CommandRuntime) => {
   runtime.pi.registerEntryRenderer?.(
     "advisor-manual-call",
-    (entry, { expanded }, theme) => {
-      const { progressId, question } = (entry.data ?? {}) as {
-        progressId?: string;
-        question?: string;
-      };
-      const progress = progressId
-        ? runtime.manualProgress.get(progressId)
-        : undefined;
-      return progress
-        ? new ManualAdvisorProgressComponent(
-            question,
-            progress,
-            Boolean(expanded),
-            theme
-          )
-        : renderAdvisorCallBox(question, theme);
-    }
+    manualCallRenderer(runtime)
   );
-
   runtime.pi.registerMessageRenderer?.(
     "advisor-manual-result",
-    (message, { expanded }, theme) => {
-      const details = message.details as
-        | { advisor?: string; text?: string; usage?: unknown }
-        | undefined;
-      const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-      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));
-      }
-      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),
-          0,
-          0,
-          getMarkdownTheme()
-        )
-      );
-      return box;
-    }
+    manualResultRenderer
   );
 };

package/src/commands/runtime.ts

@@ -2,6 +2,7 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+
 import { getAdvisorSettings } from "../config/state.ts";
 import { notifyHerdrAdvisorFailure } from "../herdr.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
@@ -25,6 +26,18 @@ export const notify = (
   }
 };
 
+const reportManualBudgetExhausted = (ctx: ExtensionContext) => {
+  const message = "Advisor call budget exhausted for this session.";
+  notify(ctx, message, "warning");
+  notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
+};
+
+const requestManualRender = (ctx: ExtensionContext) => {
+  if (ctx.hasUI) {
+    ctx.ui.setStatus("advisor-manual", undefined);
+  }
+};
+
 class CommandRuntime implements CommandRuntimeContract {
   readonly advisorSessionState: AdvisorSessionState;
   readonly manualConsultations = new Map<AbortController, symbol>();
@@ -34,7 +47,9 @@ class CommandRuntime implements CommandRuntimeContract {
     ReturnType<typeof setInterval>
   >();
   readonly pi: ExtensionAPI;
+  readonly reportManualBudgetExhausted = reportManualBudgetExhausted;
   readonly requestAdvisor: ManualConsult;
+  readonly requestManualRender = requestManualRender;
   readonly scoutStatus: ScoutStatusManager;
   manualProgressSequence = 0;
   pendingExecutorModelRef: string | undefined;
@@ -59,8 +74,7 @@ class CommandRuntime implements CommandRuntimeContract {
           undefined,
           undefined,
           undefined,
-          onScout,
-          undefined
+          onScout
         ));
   }
 
@@ -94,18 +108,6 @@ class CommandRuntime implements CommandRuntimeContract {
       );
     }
   }
-
-  reportManualBudgetExhausted(ctx: ExtensionContext) {
-    const message = "Advisor call budget exhausted for this session.";
-    notify(ctx, message, "warning");
-    notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
-  }
-
-  requestManualRender(ctx: ExtensionContext) {
-    if (ctx.hasUI) {
-      ctx.ui.setStatus("advisor-manual", undefined);
-    }
-  }
 }
 
 export const createCommandRuntime = (

package/src/commands/settings-commands.ts

@@ -7,7 +7,11 @@ import {
 import { saveConfig } from "../config/storage.ts";
 import { AdvisorSettingsSelector } from "../ui/settings-selector.ts";
 import { loadCommandConfig } from "./activation-preparation.ts";
-import { CONTEXT_PRESETS, EFFORT_LEVELS } from "./model-options.ts";
+import {
+  CONTEXT_PRESETS,
+  EFFORT_LEVELS,
+  getConfiguredModelRefs,
+} from "./model-options.ts";
 import { notify } from "./runtime.ts";
 import { saveAdvisorSettings } from "./settings-persistence.ts";
 import type { CommandRuntime } from "./types.ts";
@@ -21,12 +25,14 @@ export const registerSettingsCommands = (runtime: CommandRuntime) => {
       }
 
       const initial = getAdvisorSettings();
-      await ctx.ui.custom<void>(
-        (tui, theme, _keybindings, done) =>
+      await ctx.ui.custom<undefined>(
+        (tui, theme, keybindings, done) =>
           new AdvisorSettingsSelector({
             effortLevels: EFFORT_LEVELS,
             initial,
-            onCancel: () => done(),
+            keybindings,
+            modelRefs: getConfiguredModelRefs(ctx),
+            onCancel: () => done(undefined),
             onChange: (settings) => {
               try {
                 saveAdvisorSettings(ctx, settings);

package/src/commands/settings-persistence.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 import {
   getPersistedModelRefs,
   setAdvisorAutoLoopGateRef,
@@ -25,6 +26,7 @@ import {
   setAdvisorJevTurnGateNoulThresholdRef,
   setAdvisorLoopThresholdRef,
   setAdvisorMaxCallsPerSessionRef,
+  setAdvisorModelWhitelistRef,
   setAdvisorOutcomeLoggingRef,
   setAdvisorPlanGateRef,
   setAdvisorRedactSecretsRef,
@@ -56,8 +58,7 @@ import {
 } from "../config/types.ts";
 import type { AdvisorSettings } from "../ui/types.ts";
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
-const applyAdvisorSettings = (settings: AdvisorSettings) => {
+const applySessionSettings = (settings: AdvisorSettings) => {
   setAdvisorEffortRef(
     settings.effort === "Default (Model Default)" ? undefined : settings.effort
   );
@@ -71,6 +72,7 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAdvisorAutoLoopGateRef(settings.autoLoopGate ?? true);
   setAdvisorLoopThresholdRef(settings.loopThreshold ?? 3);
   setAdvisorMaxCallsPerSessionRef(settings.maxCallsPerSession);
+  setAdvisorModelWhitelistRef(settings.modelWhitelist ?? []);
   setAdvisorSessionSummaryRef(settings.sessionSummary ?? false);
   setAdvisorScoutEnabledRef(settings.scoutEnabled ?? false);
   setShowUsageDetailsRef(settings.showUsageDetails ?? true);
@@ -79,6 +81,9 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAlwaysOnRef(settings.alwaysOn ?? false);
   setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
   setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
+};
+
+const applyJevSettings = (settings: AdvisorSettings) => {
   setAdvisorJevFilterEnabledRef(settings.jevFilterEnabled ?? false);
   setAdvisorJevFilterSkipConfidenceRef(
     settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE
@@ -104,6 +109,9 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAdvisorJevTurnGateNoulThresholdRef(
     settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD
   );
+};
+
+const applyDisclosureSettings = (settings: AdvisorSettings) => {
   setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
   setAdvisorToolResultMaxBytesRef(settings.toolResultMaxBytes ?? 50 * 1024);
   setAdvisorRedactSecretsRef(settings.redactSecrets ?? false);
@@ -115,6 +123,12 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAdvisorOutcomeLoggingRef(settings.outcomeLogging ?? false);
 };
 
+const applyAdvisorSettings = (settings: AdvisorSettings) => {
+  applySessionSettings(settings);
+  applyJevSettings(settings);
+  applyDisclosureSettings(settings);
+};
+
 export const saveAdvisorSettings = (
   ctx: ExtensionContext,
   settings: AdvisorSettings

package/src/commands/types.ts

@@ -2,6 +2,7 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+
 import type { GitContextLevel } from "../git.ts";
 import type { ScoutLifecycleEvent } from "../scout.ts";
 import type { AdvisorSessionState } from "../session-state.ts";

package/src/commands.ts

@@ -1,4 +1,3 @@
-// biome-ignore lint/performance/noBarrelFile: this facade intentionally preserves the public command module contract.
 export { registerCommands } from "./commands/registration.ts";
 export type {
   CommandDependencies,

package/src/config/args.ts

@@ -9,7 +9,7 @@ import {
 import { MAX_CONTEXT_MAX_CHARS } from "./types.ts";
 import { isValidContextMaxChars } from "./validation.ts";
 
-const ARGUMENT_WHITESPACE = /\s+/;
+const ARGUMENT_WHITESPACE = /\s+/u;
 
 export const parseArgs = (args: string): string | undefined => {
   let nextExecutor = executorRef;

package/src/config/defaults.ts

@@ -23,6 +23,7 @@ import {
   setAdvisorJevTurnGateNoulThresholdRef,
   setAdvisorLoopThresholdRef,
   setAdvisorMaxCallsPerSessionRef,
+  setAdvisorModelWhitelistRef,
   setAdvisorOutcomeLoggingRef,
   setAdvisorPlanGateRef,
   setAdvisorRedactSecretsRef,
@@ -77,6 +78,7 @@ export const resetDefaults = () => {
   setAdvisorAutoLoopGateRef(true);
   setAdvisorLoopThresholdRef(3);
   setAdvisorMaxCallsPerSessionRef(undefined);
+  setAdvisorModelWhitelistRef([]);
   setAdvisorSessionSummaryRef(false);
   setSimpleModeRef(false);
   setAlwaysOnRef(false);
@@ -114,7 +116,7 @@ const applyOptionalConfig = <Key extends keyof AdvisorConfig>(
 ) => {
   const value = config[key];
   if (value !== undefined) {
-    apply(value as NonNullable<AdvisorConfig[Key]>);
+    apply(value);
   }
 };
 
@@ -166,6 +168,11 @@ export const applyConfig = (config: AdvisorConfig) => {
     "advisorMaxCallsPerSession",
     setAdvisorMaxCallsPerSessionRef
   );
+  applyOptionalConfig(
+    config,
+    "advisorModelWhitelist",
+    setAdvisorModelWhitelistRef
+  );
   applyOptionalConfig(
     config,
     "advisorSessionSummary",

package/src/config/schema.ts

@@ -1,3 +1,5 @@
+import { isString } from "../content-utils.ts";
+import type { JsonValue } from "../content-utils.ts";
 import { GIT_CONTEXT_LEVELS, isValidGitContextLevel } from "../git.ts";
 import {
   advisorAutoLoopGateRef,
@@ -24,6 +26,7 @@ import {
   advisorJevTurnGateNoulThresholdRef,
   advisorLoopThresholdRef,
   advisorMaxCallsPerSessionRef,
+  advisorModelWhitelistRef,
   advisorOutcomeLoggingRef,
   advisorPlanGateRef,
   advisorRedactSecretsRef,
@@ -43,12 +46,15 @@ import {
   showUsageFooterRef,
   simpleModeRef,
 } from "./state.ts";
+import type {
+  AdvisorConfig,
+  AdvisorConfigValue,
+  JevTransport,
+} from "./types.ts";
 import {
   ADVISOR_TOOL_POLICIES,
-  type AdvisorConfig,
   GATE_FAILURE_MODES,
   JEV_TRANSPORTS,
-  type JevTransport,
   MAX_CONTEXT_MAX_CHARS,
 } from "./types.ts";
 
@@ -56,6 +62,15 @@ import {
 const configuredModelRef = (value: string | undefined): string | undefined =>
   value?.trim() || undefined;
 
+const isNonEmptyModel = (model: unknown): model is string =>
+  typeof model === "string" && model.trim().length > 0;
+
+export const isValidAdvisorModelWhitelist = (
+  value: unknown
+): value is string[] => Array.isArray(value) && value.every(isNonEmptyModel);
+
+const ADVISOR_TOOL_POLICY_NAMES = new Set<string>(ADVISOR_TOOL_POLICIES);
+
 export const isValidAdvisorToolPolicies = (
   value: unknown
 ): value is Record<string, (typeof ADVISOR_TOOL_POLICIES)[number]> => {
@@ -65,10 +80,8 @@ export const isValidAdvisorToolPolicies = (
   return Object.entries(value).every(
     ([toolName, policy]) =>
       toolName.trim().length > 0 &&
-      typeof policy === "string" &&
-      ADVISOR_TOOL_POLICIES.includes(
-        policy as (typeof ADVISOR_TOOL_POLICIES)[number]
-      )
+      isString(policy) &&
+      ADVISOR_TOOL_POLICY_NAMES.has(policy)
   );
 };
 
@@ -87,11 +100,12 @@ export const isValidLoopThreshold = (value: unknown): value is number =>
 export const isValidMaxCallsPerSession = (value: unknown): value is number =>
   nonNegativeSafeInteger(value);
 
+const GATE_FAILURE_MODE_NAMES = new Set<string>(GATE_FAILURE_MODES);
+
 export const isValidGateFailureMode = (
   value: unknown
 ): value is (typeof GATE_FAILURE_MODES)[number] =>
-  typeof value === "string" &&
-  GATE_FAILURE_MODES.includes(value as (typeof GATE_FAILURE_MODES)[number]);
+  isString(value) && GATE_FAILURE_MODE_NAMES.has(value);
 
 export const isValidToolResultMaxLines = (value: unknown): value is number =>
   nonNegativeSafeInteger(value);
@@ -120,8 +134,10 @@ export const isValidJevNoulMargin = (value: unknown): value is number =>
   value >= 0 &&
   value <= 0.5;
 
+const JEV_TRANSPORT_NAMES = new Set<string>(JEV_TRANSPORTS);
+
 export const isValidJevTransport = (value: unknown): value is JevTransport =>
-  typeof value === "string" && JEV_TRANSPORTS.includes(value as JevTransport);
+  isString(value) && JEV_TRANSPORT_NAMES.has(value);
 
 /** One declarative entry per AdvisorConfig key: JSON type, persistence, and
  * the live runtime value behind it. Validation and storage derive from this
@@ -130,13 +146,13 @@ export interface ConfigKeySchema {
   /** Human-readable accepted-value phrase for error messages. */
   accepted: string;
   /** Live runtime value captured by saveConfig. */
-  current: () => unknown;
+  current: () => AdvisorConfigValue;
   /** Included in the state captured and diffed by saveConfig. */
   persisted: boolean;
   /** JSON value type used for the base type check. */
-  type: "string" | "boolean" | "number" | "enum" | "object";
+  type: "string" | "boolean" | "number" | "enum" | "object" | "array";
   /** Type beyond the JSON type, for enum and object keys. */
-  validate?: (value: unknown) => boolean;
+  validate?: (value: unknown) => value is JsonValue;
 }
 
 export const CONFIG_SCHEMA = {
@@ -297,6 +313,13 @@ export const CONFIG_SCHEMA = {
     type: "number",
     validate: isValidMaxCallsPerSession,
   },
+  advisorModelWhitelist: {
+    accepted: "an array of non-empty provider/model strings",
+    current: () => [...advisorModelWhitelistRef],
+    persisted: true,
+    type: "array",
+    validate: isValidAdvisorModelWhitelist,
+  },
   advisorOutcomeLogging: {
     accepted: "true or false",
     current: () => advisorOutcomeLoggingRef,
@@ -415,6 +438,9 @@ export const CONFIG_SCHEMA = {
 
 export type ConfigKey = keyof typeof CONFIG_SCHEMA;
 
+// SAFETY: CONFIG_SCHEMA satisfies Record<keyof AdvisorConfig, ConfigKeySchema>, so Object.keys yields exactly ConfigKey.
+export const configKeys = Object.keys(CONFIG_SCHEMA) as ConfigKey[];
+
 /** Keys saveConfig captures, diffs, and writes to advisor.json. */
 export type PersistedConfigKey = {
   [Key in ConfigKey]: (typeof CONFIG_SCHEMA)[Key]["persisted"] extends true
@@ -422,11 +448,10 @@ export type PersistedConfigKey = {
     : never;
 }[ConfigKey];
 
-export const SAVED_CONFIG_KEYS = (
-  Object.keys(CONFIG_SCHEMA) as ConfigKey[]
-).filter(
-  (key) => CONFIG_SCHEMA[key].persisted
-) as readonly PersistedConfigKey[];
+export const SAVED_CONFIG_KEYS: readonly PersistedConfigKey[] =
+  configKeys.filter(
+    (key): key is PersistedConfigKey => CONFIG_SCHEMA[key].persisted
+  );
 
 /** Widened per-key view for consumers that index by dynamic key. */
 const SCHEMA_BY_KEY: Record<ConfigKey, ConfigKeySchema> = CONFIG_SCHEMA;

package/src/config/state.ts

@@ -1,6 +1,5 @@
 import type { GitContextLevel } from "../git.ts";
 import {
-  type AdvisorToolPolicies,
   DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
@@ -15,8 +14,11 @@ import {
   DEFAULT_JEV_TRANSPORT,
   DEFAULT_JEV_TURN_GATE_EVERY_TURNS,
   DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
-  type GateFailureMode,
-  type JevTransport,
+} from "./types.ts";
+import type {
+  AdvisorToolPolicies,
+  GateFailureMode,
+  JevTransport,
 } from "./types.ts";
 
 // An empty ref means no model has been selected yet.
@@ -36,6 +38,7 @@ export let advisorBlockOnBlockedRef = true;
 export let advisorAutoLoopGateRef = true;
 export let advisorLoopThresholdRef = 3;
 export let advisorMaxCallsPerSessionRef: number | undefined;
+export let advisorModelWhitelistRef: string[] = [];
 export let advisorSessionSummaryRef = false;
 export let simpleModeRef = false;
 export let alwaysOnRef = false;
@@ -125,6 +128,11 @@ export const setAdvisorLoopThresholdRef = (value: number) => {
 export const setAdvisorMaxCallsPerSessionRef = (value: number | undefined) => {
   advisorMaxCallsPerSessionRef = value;
 };
+export const setAdvisorModelWhitelistRef = (models: string[]) => {
+  advisorModelWhitelistRef = [
+    ...new Set(models.map((model) => model.trim()).filter(Boolean)),
+  ];
+};
 export const setAdvisorSessionSummaryRef = (enabled: boolean) => {
   advisorSessionSummaryRef = enabled;
 };
@@ -243,6 +251,7 @@ export const getAdvisorSettings = () => ({
   jevTurnGateNoulThreshold: advisorJevTurnGateNoulThresholdRef,
   loopThreshold: advisorLoopThresholdRef,
   maxCallsPerSession: advisorMaxCallsPerSessionRef,
+  modelWhitelist: [...advisorModelWhitelistRef],
   outcomeLogging: advisorOutcomeLoggingRef,
   planGate: advisorPlanGateRef,
   redactSecrets: advisorRedactSecretsRef,

package/src/config/storage.ts

@@ -1,17 +1,18 @@
 import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import {
-  CONFIG_DIR_NAME,
-  type ExtensionContext,
-  getAgentDir,
-} from "@earendil-works/pi-coding-agent";
+
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { isRecord, isString } from "../content-utils.ts";
+import type { RecordValue } from "../content-utils.ts";
 import { applyConfig, resetDefaults } from "./defaults.ts";
 import {
   CONFIG_SCHEMA,
   configuredModelRef,
-  type PersistedConfigKey,
   SAVED_CONFIG_KEYS,
 } from "./schema.ts";
+import type { PersistedConfigKey } from "./schema.ts";
 import { setAdvisorOutcomeLoggingRef, setPersistedModelRefs } from "./state.ts";
 import type { AdvisorConfig } from "./types.ts";
 import { unknownConfigKeys, validateConfig } from "./validation.ts";
@@ -29,6 +30,7 @@ type ConfigState = {
 };
 
 const currentConfigState = (): ConfigState =>
+  // SAFETY: SAVED_CONFIG_KEYS enumerates exactly the ConfigState keys, so fromEntries yields ConfigState.
   Object.fromEntries(
     SAVED_CONFIG_KEYS.map((key) => [key, CONFIG_SCHEMA[key].current()])
   ) as ConfigState;
@@ -41,12 +43,10 @@ const sameConfigValue = <Value>(left: Value, right: Value) =>
  * preserved like any unknown key, and never trigger the typo warning. */
 const RESERVED_ADVISOR_JSON_KEYS = new Set(["typesafe_api_key"]);
 
-export const readExistingConfig = (path: string): Record<string, unknown> => {
+export const readExistingConfig = (path: string): RecordValue => {
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {};
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+    return isRecord(parsed) ? parsed : {};
   } catch {
     return {};
   }
@@ -61,12 +61,14 @@ const shouldPersistConfigKey = (
   (key !== "executor" || persistExecutor);
 
 const applyChangedConfigValues = (
-  data: Record<string, unknown>,
+  existing: RecordValue,
   current: ConfigState,
   changedKeys: readonly SavedConfigKey[],
   persistAdvisor: boolean,
   persistExecutor: boolean
-) => {
+): RecordValue => {
+  const dropped = new Set<string>();
+  const data: RecordValue = { ...existing };
   for (const key of changedKeys) {
     if (!shouldPersistConfigKey(key, persistAdvisor, persistExecutor)) {
       continue;
@@ -74,11 +76,21 @@ const applyChangedConfigValues = (
     const value = current[key];
     const isEmptyModelRef = (key === "advisor" || key === "executor") && !value;
     if (value === undefined || isEmptyModelRef) {
-      delete data[key];
+      dropped.add(key);
     } else {
       data[key] = value;
     }
   }
+  if (dropped.size === 0) {
+    return data;
+  }
+  const retained: RecordValue = {};
+  for (const key of Object.keys(data)) {
+    if (!dropped.has(key)) {
+      retained[key] = data[key];
+    }
+  }
+  return retained;
 };
 
 // Tracks the last load/save state so a later save merges fresh disk contents instead of overwriting an external edit.
@@ -86,7 +98,7 @@ let loadedConfigState: ConfigState | undefined;
 let loadedConfigPath: string | undefined;
 
 const readConfig = (path: string): AdvisorConfig => {
-  const config = JSON.parse(readFileSync(path, "utf8"));
+  const config = JSON.parse(readFileSync(path, "utf-8"));
   validateConfig(config, path);
   return config;
 };
@@ -142,9 +154,9 @@ export const loadConfig = (_ctx: ExtensionContext) => {
   );
   if (globalConfig) {
     applyConfig(globalConfig);
-    const unknownKeys = unknownConfigKeys(
-      globalConfig as Record<string, unknown>
-    ).filter((key) => !RESERVED_ADVISOR_JSON_KEYS.has(key));
+    const unknownKeys = unknownConfigKeys(globalConfig).filter(
+      (key) => !RESERVED_ADVISOR_JSON_KEYS.has(key)
+    );
     const warningIdentity = `${global}:${configIdentity(global)}`;
     if (
       unknownKeys.length > 0 &&
@@ -196,9 +208,8 @@ export const saveConfig = (
   if (changedKeys.length === 0) {
     return path;
   }
-  const data = { ...existing };
-  applyChangedConfigValues(
-    data,
+  const data = applyChangedConfigValues(
+    existing,
     current,
     changedKeys,
     persistAdvisor,
@@ -211,14 +222,14 @@ export const saveConfig = (
     nextLoadedState.advisor = baseline
       ? baseline.advisor
       : configuredModelRef(
-          typeof existing.advisor === "string" ? existing.advisor : undefined
+          isString(existing.advisor) ? existing.advisor : undefined
         );
   }
   if (!persistExecutor) {
     nextLoadedState.executor = baseline
       ? baseline.executor
       : configuredModelRef(
-          typeof existing.executor === "string" ? existing.executor : undefined
+          isString(existing.executor) ? existing.executor : undefined
         );
   }
   loadedConfigState = nextLoadedState;