pi-advisor-flow 0.5.6 → 0.7.0

package/src/config/defaults.ts

@@ -10,6 +10,17 @@ import {
   setAdvisorGitContextMaxCharsRef,
   setAdvisorGitContextRef,
   setAdvisorHerdrIntegrationRef,
+  setAdvisorJevDigestMaxCharsRef,
+  setAdvisorJevFilterEnabledRef,
+  setAdvisorJevFilterNoulMarginRef,
+  setAdvisorJevFilterOverrideWindowRef,
+  setAdvisorJevFilterSkipConfidenceRef,
+  setAdvisorJevModelRef,
+  setAdvisorJevPricePerMtokRef,
+  setAdvisorJevTimeoutMsRef,
+  setAdvisorJevTransportRef,
+  setAdvisorJevTurnGateEveryTurnsRef,
+  setAdvisorJevTurnGateNoulThresholdRef,
   setAdvisorLoopThresholdRef,
   setAdvisorMaxCallsPerSessionRef,
   setAdvisorOutcomeLoggingRef,
@@ -31,14 +42,24 @@ import {
   setShowUsageDetailsRef,
   setShowUsageFooterRef,
   setSimpleModeRef,
-} from "./state.js";
-import type { AdvisorConfig } from "./types.js";
+} from "./state.ts";
+import type { AdvisorConfig } from "./types.ts";
 import {
   DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
   DEFAULT_CONTEXT_MAX_CHARS,
-} from "./types.js";
+  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";
 
 export const resetDefaults = () => {
   setExecutorRef("");
@@ -61,6 +82,17 @@ export const resetDefaults = () => {
   setAlwaysOnRef(false);
   setAdvisorFailureModeRef("block-session");
   setAdvisorHerdrIntegrationRef(true);
+  setAdvisorJevModelRef(DEFAULT_JEV_MODEL);
+  setAdvisorJevFilterEnabledRef(false);
+  setAdvisorJevFilterSkipConfidenceRef(DEFAULT_JEV_FILTER_SKIP_CONFIDENCE);
+  setAdvisorJevFilterNoulMarginRef(DEFAULT_JEV_FILTER_NOUL_MARGIN);
+  setAdvisorJevFilterOverrideWindowRef(DEFAULT_JEV_FILTER_OVERRIDE_WINDOW);
+  setAdvisorJevTimeoutMsRef(DEFAULT_JEV_TIMEOUT_MS);
+  setAdvisorJevDigestMaxCharsRef(DEFAULT_JEV_DIGEST_MAX_CHARS);
+  setAdvisorJevPricePerMtokRef(DEFAULT_JEV_PRICE_PER_MTOK);
+  setAdvisorJevTransportRef(DEFAULT_JEV_TRANSPORT);
+  setAdvisorJevTurnGateEveryTurnsRef(DEFAULT_JEV_TURN_GATE_EVERY_TURNS);
+  setAdvisorJevTurnGateNoulThresholdRef(DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD);
   setAdvisorToolResultMaxLinesRef(DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES);
   setAdvisorToolResultMaxBytesRef(DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES);
   setAdvisorRedactSecretsRef(false);
@@ -150,6 +182,49 @@ export const applyConfig = (config: AdvisorConfig) => {
     "advisorHerdrIntegration",
     setAdvisorHerdrIntegrationRef
   );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterEnabled",
+    setAdvisorJevFilterEnabledRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterSkipConfidence",
+    setAdvisorJevFilterSkipConfidenceRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterNoulMargin",
+    setAdvisorJevFilterNoulMarginRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterOverrideWindow",
+    setAdvisorJevFilterOverrideWindowRef
+  );
+  applyNonEmptyStringConfig(config.advisorJevModel, setAdvisorJevModelRef);
+  applyOptionalConfig(config, "advisorJevTimeoutMs", setAdvisorJevTimeoutMsRef);
+  applyOptionalConfig(
+    config,
+    "advisorJevDigestMaxChars",
+    setAdvisorJevDigestMaxCharsRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevPricePerMtok",
+    setAdvisorJevPricePerMtokRef
+  );
+  applyOptionalConfig(config, "advisorJevTransport", setAdvisorJevTransportRef);
+  applyOptionalConfig(
+    config,
+    "advisorJevTurnGateEveryTurns",
+    setAdvisorJevTurnGateEveryTurnsRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevTurnGateNoulThreshold",
+    setAdvisorJevTurnGateNoulThresholdRef
+  );
   applyOptionalConfig(
     config,
     "advisorToolResultMaxLines",

package/src/config/schema.ts

@@ -0,0 +1,434 @@
+import { GIT_CONTEXT_LEVELS, isValidGitContextLevel } from "../git.ts";
+import {
+  advisorAutoLoopGateRef,
+  advisorBlockOnBlockedRef,
+  advisorCollapseResponsesRef,
+  advisorCompletionGateRef,
+  advisorCustomInvocationRef,
+  advisorEffortRef,
+  advisorFailureGateRef,
+  advisorFailureModeRef,
+  advisorGitContextMaxCharsRef,
+  advisorGitContextRef,
+  advisorHerdrIntegrationRef,
+  advisorJevDigestMaxCharsRef,
+  advisorJevFilterEnabledRef,
+  advisorJevFilterNoulMarginRef,
+  advisorJevFilterOverrideWindowRef,
+  advisorJevFilterSkipConfidenceRef,
+  advisorJevModelRef,
+  advisorJevPricePerMtokRef,
+  advisorJevTimeoutMsRef,
+  advisorJevTransportRef,
+  advisorJevTurnGateEveryTurnsRef,
+  advisorJevTurnGateNoulThresholdRef,
+  advisorLoopThresholdRef,
+  advisorMaxCallsPerSessionRef,
+  advisorOutcomeLoggingRef,
+  advisorPlanGateRef,
+  advisorRedactSecretsRef,
+  advisorRef,
+  advisorScoutEnabledRef,
+  advisorSessionSummaryRef,
+  advisorToolPoliciesRef,
+  advisorToolResultMaxBytesRef,
+  advisorToolResultMaxLinesRef,
+  advisorTrackedFileContentRef,
+  advisorUntrackedContentRef,
+  alwaysOnRef,
+  contextMaxCharsRef,
+  executorEffortRef,
+  executorRef,
+  showUsageDetailsRef,
+  showUsageFooterRef,
+  simpleModeRef,
+} from "./state.ts";
+import {
+  ADVISOR_TOOL_POLICIES,
+  type AdvisorConfig,
+  GATE_FAILURE_MODES,
+  JEV_TRANSPORTS,
+  type JevTransport,
+  MAX_CONTEXT_MAX_CHARS,
+} from "./types.ts";
+
+/** An empty ref means no model has been selected yet. */
+const configuredModelRef = (value: string | undefined): string | undefined =>
+  value?.trim() || undefined;
+
+export const isValidAdvisorToolPolicies = (
+  value: unknown
+): value is Record<string, (typeof ADVISOR_TOOL_POLICIES)[number]> => {
+  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 (typeof ADVISOR_TOOL_POLICIES)[number]
+      )
+  );
+};
+
+const nonNegativeSafeInteger = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+
+export const isValidContextMaxChars = (value: unknown): value is number =>
+  typeof value === "number" &&
+  Number.isSafeInteger(value) &&
+  value >= 0 &&
+  value <= MAX_CONTEXT_MAX_CHARS;
+
+export const isValidLoopThreshold = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 2;
+
+export const isValidMaxCallsPerSession = (value: unknown): value is number =>
+  nonNegativeSafeInteger(value);
+
+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]);
+
+export const isValidToolResultMaxLines = (value: unknown): value is number =>
+  nonNegativeSafeInteger(value);
+
+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;
+
+export const isValidJevTransport = (value: unknown): value is JevTransport =>
+  typeof value === "string" && JEV_TRANSPORTS.includes(value as JevTransport);
+
+/** 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. */
+export interface ConfigKeySchema {
+  /** Human-readable accepted-value phrase for error messages. */
+  accepted: string;
+  /** Live runtime value captured by saveConfig. */
+  current: () => unknown;
+  /** 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 beyond the JSON type, for enum and object keys. */
+  validate?: (value: unknown) => boolean;
+}
+
+export const CONFIG_SCHEMA = {
+  advisor: {
+    accepted: "a provider/model string",
+    current: () => configuredModelRef(advisorRef),
+    persisted: true,
+    type: "string",
+  },
+  advisorAutoLoopGate: {
+    accepted: "true or false",
+    current: () => advisorAutoLoopGateRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorBlockOnBlocked: {
+    accepted: "true or false",
+    current: () => advisorBlockOnBlockedRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorCollapseResponses: {
+    accepted: "true or false",
+    current: () => advisorCollapseResponsesRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorCompletionGate: {
+    accepted: "true or false",
+    current: () => advisorCompletionGateRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorCustomInvocation: {
+    accepted: "a string",
+    current: () => advisorCustomInvocationRef,
+    persisted: true,
+    type: "string",
+  },
+  advisorEffort: {
+    accepted: "a string",
+    current: () => advisorEffortRef,
+    persisted: true,
+    type: "string",
+  },
+  advisorFailureGate: {
+    accepted: "true or false",
+    current: () => advisorFailureGateRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorGitContext: {
+    accepted: GIT_CONTEXT_LEVELS.join(", "),
+    current: () => advisorGitContextRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidGitContextLevel,
+  },
+  advisorGitContextMaxChars: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorGitContextMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger,
+  },
+  advisorHerdrIntegration: {
+    accepted: "true or false",
+    current: () => advisorHerdrIntegrationRef,
+    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,
+    persisted: true,
+    type: "number",
+    validate: isValidLoopThreshold,
+  },
+  advisorMaxCallsPerSession: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorMaxCallsPerSessionRef,
+    persisted: true,
+    type: "number",
+    validate: isValidMaxCallsPerSession,
+  },
+  advisorOutcomeLogging: {
+    accepted: "true or false",
+    current: () => advisorOutcomeLoggingRef,
+    persisted: false,
+    type: "boolean",
+  },
+  advisorPlanGate: {
+    accepted: "true or false",
+    current: () => advisorPlanGateRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorRedactSecrets: {
+    accepted: "true or false",
+    current: () => advisorRedactSecretsRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorScoutEnabled: {
+    accepted: "true or false",
+    current: () => advisorScoutEnabledRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorSessionSummary: {
+    accepted: "true or false",
+    current: () => advisorSessionSummaryRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorToolPolicies: {
+    accepted:
+      "a JSON object with non-empty tool names and full, summary, or exclude values",
+    current: () => ({ ...advisorToolPoliciesRef }),
+    persisted: true,
+    type: "object",
+    validate: isValidAdvisorToolPolicies,
+  },
+  advisorToolResultMaxBytes: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorToolResultMaxBytesRef,
+    persisted: true,
+    type: "number",
+    validate: isValidToolResultMaxBytes,
+  },
+  advisorToolResultMaxLines: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorToolResultMaxLinesRef,
+    persisted: true,
+    type: "number",
+    validate: isValidToolResultMaxLines,
+  },
+  advisorTrackedFileContent: {
+    accepted: "true or false",
+    current: () => advisorTrackedFileContentRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorUntrackedContent: {
+    accepted: "true or false",
+    current: () => advisorUntrackedContentRef,
+    persisted: true,
+    type: "boolean",
+  },
+  alwaysOn: {
+    accepted: "true or false",
+    current: () => alwaysOnRef,
+    persisted: true,
+    type: "boolean",
+  },
+  contextMaxChars: {
+    accepted: `a safe integer from 0 through ${MAX_CONTEXT_MAX_CHARS}`,
+    current: () => contextMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidContextMaxChars,
+  },
+  executor: {
+    accepted: "a provider/model string",
+    current: () => configuredModelRef(executorRef),
+    persisted: true,
+    type: "string",
+  },
+  executorEffort: {
+    accepted: "a string",
+    current: () => executorEffortRef,
+    persisted: true,
+    type: "string",
+  },
+  gateFailureMode: {
+    accepted: GATE_FAILURE_MODES.join(", "),
+    current: () => advisorFailureModeRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidGateFailureMode,
+  },
+  showUsageDetails: {
+    accepted: "true or false",
+    current: () => showUsageDetailsRef,
+    persisted: true,
+    type: "boolean",
+  },
+  showUsageFooter: {
+    accepted: "true or false",
+    current: () => showUsageFooterRef,
+    persisted: true,
+    type: "boolean",
+  },
+  simpleMode: {
+    accepted: "true or false",
+    current: () => simpleModeRef,
+    persisted: true,
+    type: "boolean",
+  },
+} as const satisfies Record<keyof AdvisorConfig, ConfigKeySchema>;
+
+export type ConfigKey = keyof typeof CONFIG_SCHEMA;
+
+/** Keys saveConfig captures, diffs, and writes to advisor.json. */
+export type PersistedConfigKey = {
+  [Key in ConfigKey]: (typeof CONFIG_SCHEMA)[Key]["persisted"] extends true
+    ? Key
+    : never;
+}[ConfigKey];
+
+export const SAVED_CONFIG_KEYS = (
+  Object.keys(CONFIG_SCHEMA) as ConfigKey[]
+).filter(
+  (key) => CONFIG_SCHEMA[key].persisted
+) as readonly PersistedConfigKey[];
+
+/** Widened per-key view for consumers that index by dynamic key. */
+const SCHEMA_BY_KEY: Record<ConfigKey, ConfigKeySchema> = CONFIG_SCHEMA;
+
+export { configuredModelRef, SCHEMA_BY_KEY };

package/src/config/state.ts

@@ -1,12 +1,23 @@
-import type { GitContextLevel } from "../git.js";
+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,
+  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,
   type GateFailureMode,
-} from "./types.js";
+  type JevTransport,
+} from "./types.ts";
 
 // An empty ref means no model has been selected yet.
 export let executorRef = "";
@@ -30,6 +41,20 @@ 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;
@@ -117,6 +142,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,6 +230,17 @@ 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,
   outcomeLogging: advisorOutcomeLoggingRef,