pi-advisor-flow 0.6.0 → 0.8.0

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,
@@ -11,8 +13,20 @@ import {
   advisorGitContextMaxCharsRef,
   advisorGitContextRef,
   advisorHerdrIntegrationRef,
+  advisorJevDigestMaxCharsRef,
+  advisorJevFilterEnabledRef,
+  advisorJevFilterNoulMarginRef,
+  advisorJevFilterOverrideWindowRef,
+  advisorJevFilterSkipConfidenceRef,
+  advisorJevModelRef,
+  advisorJevPricePerMtokRef,
+  advisorJevTimeoutMsRef,
+  advisorJevTransportRef,
+  advisorJevTurnGateEveryTurnsRef,
+  advisorJevTurnGateNoulThresholdRef,
   advisorLoopThresholdRef,
   advisorMaxCallsPerSessionRef,
+  advisorModelWhitelistRef,
   advisorOutcomeLoggingRef,
   advisorPlanGateRef,
   advisorRedactSecretsRef,
@@ -32,10 +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,
   MAX_CONTEXT_MAX_CHARS,
 } from "./types.ts";
 
@@ -43,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]> => {
@@ -52,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)
   );
 };
 
@@ -74,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);
@@ -86,6 +113,32 @@ export const isValidToolResultMaxLines = (value: unknown): value is number =>
 export const isValidToolResultMaxBytes = (value: unknown): value is number =>
   nonNegativeSafeInteger(value);
 
+export const isValidJevTimeoutMs = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+
+export const isValidJevDigestMaxChars = (value: unknown): value is number =>
+  nonNegativeSafeInteger(value);
+
+export const isValidJevPricePerMtok = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value) && value > 0;
+
+export const isValidJevSkipConfidence = (value: unknown): value is number =>
+  typeof value === "number" &&
+  Number.isFinite(value) &&
+  value >= 0.5 &&
+  value <= 1;
+
+export const isValidJevNoulMargin = (value: unknown): value is number =>
+  typeof value === "number" &&
+  Number.isFinite(value) &&
+  value >= 0 &&
+  value <= 0.5;
+
+const JEV_TRANSPORT_NAMES = new Set<string>(JEV_TRANSPORTS);
+
+export const isValidJevTransport = (value: unknown): value is 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
  * table; adding a setting means adding exactly one entry here. */
@@ -93,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 = {
@@ -171,6 +224,81 @@ export const CONFIG_SCHEMA = {
     persisted: true,
     type: "boolean",
   },
+  advisorJevDigestMaxChars: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorJevDigestMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevDigestMaxChars,
+  },
+  advisorJevFilterEnabled: {
+    accepted: "true or false",
+    current: () => advisorJevFilterEnabledRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorJevFilterNoulMargin: {
+    accepted: "a number from 0 through 0.5",
+    current: () => advisorJevFilterNoulMarginRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevNoulMargin,
+  },
+  advisorJevFilterOverrideWindow: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorJevFilterOverrideWindowRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger,
+  },
+  advisorJevFilterSkipConfidence: {
+    accepted: "a number between 0.5 and 1 inclusive",
+    current: () => advisorJevFilterSkipConfidenceRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevSkipConfidence,
+  },
+  advisorJevModel: {
+    accepted: "a non-empty string",
+    current: () => advisorJevModelRef,
+    persisted: true,
+    type: "string",
+  },
+  advisorJevPricePerMtok: {
+    accepted: "a positive number",
+    current: () => advisorJevPricePerMtokRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevPricePerMtok,
+  },
+  advisorJevTimeoutMs: {
+    accepted: "a positive safe integer",
+    current: () => advisorJevTimeoutMsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevTimeoutMs,
+  },
+  advisorJevTransport: {
+    accepted: JEV_TRANSPORTS.join(", "),
+    current: () => advisorJevTransportRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidJevTransport,
+  },
+  advisorJevTurnGateEveryTurns: {
+    accepted: "a non-negative safe integer (0 disables the turn gate)",
+    current: () => advisorJevTurnGateEveryTurnsRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger,
+  },
+  advisorJevTurnGateNoulThreshold: {
+    accepted: "a number between 0.5 and 1 inclusive",
+    current: () => advisorJevTurnGateNoulThresholdRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevSkipConfidence,
+  },
   advisorLoopThreshold: {
     accepted: "a safe integer of at least 2",
     current: () => advisorLoopThresholdRef,
@@ -185,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,
@@ -303,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
@@ -310,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,11 +1,24 @@
 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,
   DEFAULT_CONTEXT_MAX_CHARS,
-  type GateFailureMode,
+  DEFAULT_JEV_DIGEST_MAX_CHARS,
+  DEFAULT_JEV_FILTER_NOUL_MARGIN,
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_PRICE_PER_MTOK,
+  DEFAULT_JEV_TIMEOUT_MS,
+  DEFAULT_JEV_TRANSPORT,
+  DEFAULT_JEV_TURN_GATE_EVERY_TURNS,
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
+} from "./types.ts";
+import type {
+  AdvisorToolPolicies,
+  GateFailureMode,
+  JevTransport,
 } from "./types.ts";
 
 // An empty ref means no model has been selected yet.
@@ -25,11 +38,26 @@ 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;
 export let advisorFailureModeRef: GateFailureMode = "block-session";
 export let advisorHerdrIntegrationRef = true;
+export let advisorJevFilterEnabledRef = false;
+export let advisorJevFilterSkipConfidenceRef =
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE;
+export let advisorJevFilterNoulMarginRef = DEFAULT_JEV_FILTER_NOUL_MARGIN;
+export let advisorJevFilterOverrideWindowRef =
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW;
+export let advisorJevModelRef = DEFAULT_JEV_MODEL;
+export let advisorJevTimeoutMsRef = DEFAULT_JEV_TIMEOUT_MS;
+export let advisorJevDigestMaxCharsRef = DEFAULT_JEV_DIGEST_MAX_CHARS;
+export let advisorJevPricePerMtokRef = DEFAULT_JEV_PRICE_PER_MTOK;
+export let advisorJevTransportRef: JevTransport = DEFAULT_JEV_TRANSPORT;
+export let advisorJevTurnGateEveryTurnsRef = DEFAULT_JEV_TURN_GATE_EVERY_TURNS;
+export let advisorJevTurnGateNoulThresholdRef =
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD;
 export let advisorToolResultMaxLinesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES;
 export let advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
 export let advisorRedactSecretsRef = false;
@@ -100,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;
 };
@@ -117,6 +150,39 @@ export const setAdvisorFailureModeRef = (value: GateFailureMode) => {
 export const setAdvisorHerdrIntegrationRef = (enabled: boolean) => {
   advisorHerdrIntegrationRef = enabled;
 };
+export const setAdvisorJevFilterEnabledRef = (enabled: boolean) => {
+  advisorJevFilterEnabledRef = enabled;
+};
+export const setAdvisorJevFilterSkipConfidenceRef = (value: number) => {
+  advisorJevFilterSkipConfidenceRef = value;
+};
+export const setAdvisorJevFilterNoulMarginRef = (value: number) => {
+  advisorJevFilterNoulMarginRef = value;
+};
+export const setAdvisorJevFilterOverrideWindowRef = (value: number) => {
+  advisorJevFilterOverrideWindowRef = value;
+};
+export const setAdvisorJevModelRef = (model: string | undefined) => {
+  advisorJevModelRef = model?.trim() || DEFAULT_JEV_MODEL;
+};
+export const setAdvisorJevTimeoutMsRef = (value: number) => {
+  advisorJevTimeoutMsRef = value;
+};
+export const setAdvisorJevDigestMaxCharsRef = (value: number) => {
+  advisorJevDigestMaxCharsRef = value;
+};
+export const setAdvisorJevPricePerMtokRef = (value: number) => {
+  advisorJevPricePerMtokRef = value;
+};
+export const setAdvisorJevTransportRef = (value: JevTransport) => {
+  advisorJevTransportRef = value;
+};
+export const setAdvisorJevTurnGateEveryTurnsRef = (value: number) => {
+  advisorJevTurnGateEveryTurnsRef = value;
+};
+export const setAdvisorJevTurnGateNoulThresholdRef = (value: number) => {
+  advisorJevTurnGateNoulThresholdRef = value;
+};
 export const setAdvisorToolResultMaxLinesRef = (value: number) => {
   advisorToolResultMaxLinesRef = value;
 };
@@ -172,8 +238,20 @@ export const getAdvisorSettings = () => ({
   gitContext: advisorGitContextRef,
   gitContextMaxChars: advisorGitContextMaxCharsRef,
   herdrIntegration: advisorHerdrIntegrationRef,
+  jevDigestMaxChars: advisorJevDigestMaxCharsRef,
+  jevFilterEnabled: advisorJevFilterEnabledRef,
+  jevFilterNoulMargin: advisorJevFilterNoulMarginRef,
+  jevFilterOverrideWindow: advisorJevFilterOverrideWindowRef,
+  jevFilterSkipConfidence: advisorJevFilterSkipConfidenceRef,
+  jevModel: advisorJevModelRef,
+  jevPricePerMtok: advisorJevPricePerMtokRef,
+  jevTimeoutMs: advisorJevTimeoutMsRef,
+  jevTransport: advisorJevTransportRef,
+  jevTurnGateEveryTurns: advisorJevTurnGateEveryTurnsRef,
+  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;
@@ -36,12 +38,15 @@ const currentConfigState = (): ConfigState =>
 const sameConfigValue = <Value>(left: Value, right: Value) =>
   JSON.stringify(left) === JSON.stringify(right);
 
-const readExistingConfig = (path: string): Record<string, unknown> => {
+/** Keys advisor.json may hold that are not AdvisorConfig settings but are
+ * still legitimate (hand-placed secrets). They stay out of CONFIG_SCHEMA, are
+ * 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): 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 {};
   }
@@ -56,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;
@@ -69,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.
@@ -81,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;
 };
@@ -137,8 +154,8 @@ export const loadConfig = (_ctx: ExtensionContext) => {
   );
   if (globalConfig) {
     applyConfig(globalConfig);
-    const unknownKeys = unknownConfigKeys(
-      globalConfig as Record<string, unknown>
+    const unknownKeys = unknownConfigKeys(globalConfig).filter(
+      (key) => !RESERVED_ADVISOR_JSON_KEYS.has(key)
     );
     const warningIdentity = `${global}:${configIdentity(global)}`;
     if (
@@ -191,9 +208,8 @@ export const saveConfig = (
   if (changedKeys.length === 0) {
     return path;
   }
-  const data = { ...existing };
-  applyChangedConfigValues(
-    data,
+  const data = applyChangedConfigValues(
+    existing,
     current,
     changedKeys,
     persistAdvisor,
@@ -206,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;

package/src/config/types.ts

@@ -1,14 +1,42 @@
 import {
+  DEFAULT_MAX_BYTES as PI_DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES as PI_DEFAULT_MAX_LINES,
+} from "@earendil-works/pi-coding-agent";
+
+import type { GitContextLevel } from "../git.ts";
+
+export {
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
 } from "@earendil-works/pi-coding-agent";
-import type { GitContextLevel } from "../git.ts";
 
 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;
+const DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = PI_DEFAULT_MAX_LINES;
+const DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES = PI_DEFAULT_MAX_BYTES;
+export {
+  DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
+  DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
+};
 export const DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS = 20_000;
+export const DEFAULT_JEV_MODEL = "jev-latest";
+// Provisional: the latency benchmark was dropped from scope; revisit if live
+// measurements suggest a different bound.
+export const DEFAULT_JEV_TIMEOUT_MS = 8000;
+export const DEFAULT_JEV_DIGEST_MAX_CHARS = 4000;
+export const DEFAULT_JEV_PRICE_PER_MTOK = 0.042;
+export const DEFAULT_JEV_FILTER_SKIP_CONFIDENCE = 0.85;
+export const DEFAULT_JEV_FILTER_NOUL_MARGIN = 0.35;
+export const DEFAULT_JEV_FILTER_OVERRIDE_WINDOW = 10;
+export const DEFAULT_JEV_TURN_GATE_EVERY_TURNS = 0;
+export const DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD = 0.8;
+export type JevTransport = "auto" | "typesafe" | "openrouter";
+export const DEFAULT_JEV_TRANSPORT: JevTransport = "auto";
+export const JEV_TRANSPORTS: JevTransport[] = [
+  "auto",
+  "typesafe",
+  "openrouter",
+];
 
 export type AdvisorToolPolicy = "full" | "summary" | "exclude";
 export type AdvisorToolPolicies = Record<string, AdvisorToolPolicy>;
@@ -40,8 +68,20 @@ export interface AdvisorConfig {
   advisorGitContext?: GitContextLevel;
   advisorGitContextMaxChars?: number;
   advisorHerdrIntegration?: boolean;
+  advisorJevDigestMaxChars?: number;
+  advisorJevFilterEnabled?: boolean;
+  advisorJevFilterNoulMargin?: number;
+  advisorJevFilterOverrideWindow?: number;
+  advisorJevFilterSkipConfidence?: number;
+  advisorJevModel?: string;
+  advisorJevPricePerMtok?: number;
+  advisorJevTimeoutMs?: number;
+  advisorJevTransport?: JevTransport;
+  advisorJevTurnGateEveryTurns?: number;
+  advisorJevTurnGateNoulThreshold?: number;
   advisorLoopThreshold?: number;
   advisorMaxCallsPerSession?: number;
+  advisorModelWhitelist?: string[];
   advisorOutcomeLogging?: boolean;
   advisorPlanGate?: boolean;
   advisorRedactSecrets?: boolean;
@@ -61,3 +101,5 @@ export interface AdvisorConfig {
   showUsageFooter?: boolean;
   simpleMode?: boolean;
 }
+
+export type AdvisorConfigValue = AdvisorConfig[keyof AdvisorConfig];